packages feed

hydra-kernel (empty) → 0.16.0

raw patch · 218 files changed

+127976/−0 lines, 218 filesdep +basedep +base64-bytestringdep +bytestring

Dependencies added: base, base64-bytestring, bytestring, containers, regex-tdfa, scientific, split, text

Files

+ CHANGELOG.md view
@@ -0,0 +1,1106 @@+# Hydra changelog++All notable changes to the Hydra project are documented in this file.++This changelog tracks changes across all Hydra implementations+(Haskell, Java, Python, Scala, TypeScript, Clojure, Common Lisp, Emacs Lisp, Scheme)+and supporting infrastructure.++The format is inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)+and [Apache TinkerPop](https://github.com/apache/tinkerpop/blob/master/CHANGELOG.asciidoc).++Pre-1.0 versions are listed below.+Untagged versions correspond to in-repository version bumps that were not pushed as Git tags or Hackage releases;+they are documented here for completeness.++---++## [0.16.0] - 2026-06-09++Major themes: primitive-metadata reification, self-hosting coder DSLs with all+eight hosts passing the common test suite, finalized `hydra.packaging`, and a+deep kernel-vocabulary cleanup.++### Highlights++- **`PrimitiveDefinition` and per-namespace registry modules** with host-independent+  specs for every standard-library primitive ([#156](https://github.com/CategoricalData/hydra/issues/156), [#319](https://github.com/CategoricalData/hydra/issues/319)).+- **Self-hosting coder DSLs; all eight hosts pass the common test suite**, including+  the completed TypeScript head ([#344](https://github.com/CategoricalData/hydra/issues/344), [#126](https://github.com/CategoricalData/hydra/issues/126)).+- **Finalized `hydra.packaging`** and a unified `Module.dependencies` field ([#369](https://github.com/CategoricalData/hydra/issues/369), [#354](https://github.com/CategoricalData/hydra/issues/354)).+- **Kernel-vocabulary cleanup**: `maybe`→`optional` across kernel and hosts, plus+  order-preserving JSON objects ([#401](https://github.com/CategoricalData/hydra/issues/401), [#398](https://github.com/CategoricalData/hydra/issues/398)).++### New features++- Reify `PrimitiveDefinition` in `hydra.packaging` with per-namespace `hydra.lib.<sub>` registries ([#156](https://github.com/CategoricalData/hydra/issues/156)).+- Host-independent `comments` specifications for all standard-library primitives ([#319](https://github.com/CategoricalData/hydra/issues/319)).+- Kernel-oriented style checks in `hydra.validate.*` ([#321](https://github.com/CategoricalData/hydra/issues/321), [#351](https://github.com/CategoricalData/hydra/issues/351), [#352](https://github.com/CategoricalData/hydra/issues/352)), on a reshaped validation API ([#320](https://github.com/CategoricalData/hydra/issues/320)).+- Promote the JSON Schema coder to a full DSL coder ([#350](https://github.com/CategoricalData/hydra/issues/350)).+- Transpose coder sources into host-native DSLs for self-hosting ([#344](https://github.com/CategoricalData/hydra/issues/344), [#358](https://github.com/CategoricalData/hydra/issues/358)).+- `Term`-typed annotations replacing `Map<Name, Term>` ([#386](https://github.com/CategoricalData/hydra/issues/386)).+- Language-specific EDSL features on the kernel `Language` ([#233](https://github.com/CategoricalData/hydra/issues/233)).+- Primitive-metadata-driven laziness in eager coders ([#391](https://github.com/CategoricalData/hydra/issues/391)).+- `/test` skill and `bin/test.sh` for target-language test validation ([#387](https://github.com/CategoricalData/hydra/issues/387)).+- Automatic differentiation: a `grad` transform ([#324](https://github.com/CategoricalData/hydra/issues/324)).+- `hydra.show.error.pg` for `InvalidGraphError` ([#374](https://github.com/CategoricalData/hydra/issues/374)).++### Improvements++- Finalize `hydra.packaging`: `Binding`→`TypeDefinition`, `Module`/`Package` `comments`, `moduleName` cleanup ([#369](https://github.com/CategoricalData/hydra/issues/369), [#396](https://github.com/CategoricalData/hydra/issues/396), [#402](https://github.com/CategoricalData/hydra/issues/402), [#404](https://github.com/CategoricalData/hydra/issues/404)).+- Merge `Module.termDependencies`/`typeDependencies` into one `dependencies` field ([#354](https://github.com/CategoricalData/hydra/issues/354)).+- Resolve the `maybe`/`optional` ambiguity across kernel and all hosts ([#401](https://github.com/CategoricalData/hydra/issues/401)).+- Order-preserving JSON objects; order-sensitive `Value` equality ([#398](https://github.com/CategoricalData/hydra/issues/398)).+- Rename `Namespace`→`ModuleName` ([#316](https://github.com/CategoricalData/hydra/issues/316)) and the phantom DSL types to `Typed*` ([#397](https://github.com/CategoricalData/hydra/issues/397)).+- Move from a type-class enum to type-class names ([#275](https://github.com/CategoricalData/hydra/issues/275)).+- Repackage "eval lib" modules as kernel lib modules; promote remaining sources ([#260](https://github.com/CategoricalData/hydra/issues/260), [#355](https://github.com/CategoricalData/hydra/issues/355), [#356](https://github.com/CategoricalData/hydra/issues/356)).+- Reshape `hydra.context` into `InferenceContext` ([#368](https://github.com/CategoricalData/hydra/issues/368)).+- Streamline the Haskell, Java, Python, and Scala syntax models, re-pinning Java to SE 21 and Python to the 3.14 PEG grammar ([#297](https://github.com/CategoricalData/hydra/issues/297)).+- Adopt persistent immutable collections across hosts ([#359](https://github.com/CategoricalData/hydra/issues/359), [#360](https://github.com/CategoricalData/hydra/issues/360), [#361](https://github.com/CategoricalData/hydra/issues/361), [#362](https://github.com/CategoricalData/hydra/issues/362)).+- Migrate underscored kernel definition names to camelCase ([#348](https://github.com/CategoricalData/hydra/issues/348)).+- Tidy qualified/unqualified imports in the Haskell DSL sources ([#308](https://github.com/CategoricalData/hydra/issues/308)).+- Eliminate the `Hydra.Module.Compat` shim ([#315](https://github.com/CategoricalData/hydra/issues/315)).+- Homogenize writer conventions across target languages ([#339](https://github.com/CategoricalData/hydra/issues/339)).+- Disambiguate format-version field naming across JSON metadata ([#412](https://github.com/CategoricalData/hydra/issues/412)).+- Per-package DSL→JSON build with per-package incremental inference ([#381](https://github.com/CategoricalData/hydra/issues/381), [#395](https://github.com/CategoricalData/hydra/issues/395)).+- Prune stale `dist/` outputs; self-heal digests; exclude digests from VCS; reconcile drift; fail loud ([#357](https://github.com/CategoricalData/hydra/issues/357), [#393](https://github.com/CategoricalData/hydra/issues/393), [#405](https://github.com/CategoricalData/hydra/issues/405), [#378](https://github.com/CategoricalData/hydra/issues/378), [#379](https://github.com/CategoricalData/hydra/issues/379), [#392](https://github.com/CategoricalData/hydra/issues/392), [#414](https://github.com/CategoricalData/hydra/issues/414)).+- Accept all valid (host, target) pairs in the generation drivers ([#421](https://github.com/CategoricalData/hydra/issues/421)).+- Move Gradle build infrastructure into `heads/java/`; remove top-level `pixi.toml` ([#384](https://github.com/CategoricalData/hydra/issues/384), [#385](https://github.com/CategoricalData/hydra/issues/385)).+- Eliminate post-generation test patches; fix loader/runner kludges; re-enable test timing ([#307](https://github.com/CategoricalData/hydra/issues/307), [#309](https://github.com/CategoricalData/hydra/issues/309), [#311](https://github.com/CategoricalData/hydra/issues/311)).+- Performance/benchmarks and usability assessments ([#277](https://github.com/CategoricalData/hydra/issues/277), [#283](https://github.com/CategoricalData/hydra/issues/283)).+- Split the Hackage distribution into per-package distributions ([#418](https://github.com/CategoricalData/hydra/issues/418)).++### Bug fixes++- Encode `uint32` JSON literals as numbers, not strings ([#431](https://github.com/CategoricalData/hydra/issues/431)).+- Satisfy or suppress warnings in generated Java ([#349](https://github.com/CategoricalData/hydra/issues/349)).+- Restore JSON parser test cases (polymorphic case handling, ordering fallback) ([#336](https://github.com/CategoricalData/hydra/issues/336)).+- Keep annotations through `termAlternatives`/`typeAlternatives` adaptation ([#353](https://github.com/CategoricalData/hydra/issues/353)).+- Scala host decodes module JSON containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).+- Java coder: fix exponential `let`-bound `cases` cost ([#372](https://github.com/CategoricalData/hydra/issues/372)) and explicit type args on `PersistentMap.ofEntries` ([#394](https://github.com/CategoricalData/hydra/issues/394)).+- Python-host codegen: drop extra `pyStringToPyStrings` wrapping ([#367](https://github.com/CategoricalData/hydra/issues/367)).+- `escape_literal_char` no longer mangles RDF triples ([#363](https://github.com/CategoricalData/hydra/issues/363)).+- Sync robustness: stale coder JSON, omitted native modules, dead helper, bad source dirs ([#406](https://github.com/CategoricalData/hydra/issues/406), [#400](https://github.com/CategoricalData/hydra/issues/400), [#411](https://github.com/CategoricalData/hydra/issues/411), [#408](https://github.com/CategoricalData/hydra/issues/408)).+- Cross-host self-hosting fixes (Scala, TypeScript, and the four Lisp dialects) ([#422](https://github.com/CategoricalData/hydra/issues/422), [#423](https://github.com/CategoricalData/hydra/issues/423), [#424](https://github.com/CategoricalData/hydra/issues/424), [#429](https://github.com/CategoricalData/hydra/issues/429), [#444](https://github.com/CategoricalData/hydra/issues/444), [#366](https://github.com/CategoricalData/hydra/issues/366), [#389](https://github.com/CategoricalData/hydra/issues/389), [#407](https://github.com/CategoricalData/hydra/issues/407), [#425](https://github.com/CategoricalData/hydra/issues/425), [#426](https://github.com/CategoricalData/hydra/issues/426), [#427](https://github.com/CategoricalData/hydra/issues/427), [#432](https://github.com/CategoricalData/hydra/issues/432), [#438](https://github.com/CategoricalData/hydra/issues/438), [#439](https://github.com/CategoricalData/hydra/issues/439), [#443](https://github.com/CategoricalData/hydra/issues/443)).++### Removed++- Removed the `bigfloat` literal type from `FloatType` and `FloatValue` ([#330](https://github.com/CategoricalData/hydra/issues/330)).+  Arbitrary-precision floating-point values were inconsistently supported+  across host languages (Java/Scala in particular lacked a true IEEE 754+  arbitrary-precision implementation), and nothing in the codebase relied on+  them. `FloatType` and `FloatValue` now have only `float32` and `float64`+  variants. Removed library primitives: `bigfloatToBigint`, `bigfloatToFloat32`,+  `bigfloatToFloat64`, `bigintToBigfloat`, `float32ToBigfloat`,+  `float64ToBigfloat`, `readBigfloat`, `showBigfloat`, `roundBigfloat`. New+  primitives `float32ToFloat64` and `float64ToFloat32` (the latter lossy)+  replace the removed bigfloat-routed conversions.+- Removed `heads/haskell/bin/assemble-hackage-sdist.sh` ([#418](https://github.com/CategoricalData/hydra/issues/418)), the 0.15-era+  bridge that flattened the multi-source-dir Haskell head into one self-contained+  `hydra` sdist. Superseded by the per-package assembler (see Improvements).++### Documentation++- Comprehensive documentation refresh for 0.16 ([#383](https://github.com/CategoricalData/hydra/issues/383))+  spanning nine tracks across READMEs, `docs/`, the wiki, CLAUDE.md, and+  in-source kernel comments.+- New `docs/json-format.md` reference describing the canonical JSON wire format+  (tagged-union duality, optional-field rules, IEEE 754 sentinels, integer+  threshold).+- New wiki pages: `Design` (rationale behind each major choice) and `Inference`+  (HM type inference with class constraints).+- Cross-checked every prose doc against current code; corrected drift in+  primitive-checking sections of `docs/recipes/maintenance.md`, the `Primitive`+  shape in `docs/implementation.md` and `docs/recipes/adding-primitives.md`,+  and the build-system narrative.+- Wove motivation ("the why") through the existing doc surface rather than+  collecting it into separately-titled sidebars; landed an inference-overview+  centerpiece on the wiki ([#377](https://github.com/CategoricalData/hydra/issues/377)).+- Aligned doc vocabulary with the LambdaGraph paper and the literature review+  for the design space Hydra inhabits.+- Net-new READMEs for `packages/hydra-kernel`, `packages/hydra-ext`,+  `packages/hydra-coq`, and `packages/hydra-wasm`; top-level `README.md`+  now carries a canonical packages table.+- Audited and refreshed the Claude surface: CLAUDE.md "Where to look up X"+  table extended with rows for `docs/getting-started.md`, `docs/json-format.md`,+  and the `Design` / `Inference` wiki pages; hard-rules block reordered by+  violation frequency; `claude/pitfalls.md` superseded entries folded into+  `docs/troubleshooting.md` / recipes.+- Project-descriptor strings reviewed and aligned across 24 build / packaging+  files (Hackage synopsis, Maven Central description, PyPI / conda-forge+  classifiers, Hydra-format `package.json` files).+- `docs/index.html` (the GitHub Pages landing page) refreshed with audience+  hops into wiki Concepts / Design, `docs/getting-started.md`, and the GitHub+  repo, plus the full published-artifact list across Hackage, Maven Central,+  PyPI, and conda-forge.+- In-source kernel-code rationale comments added at key Sources sites covering+  injection / pair / either / unit-void duality, error taxonomy, variant+  records, inference-context threading, validation profiles, reduction state,+  lexical filters, name mangling, scoping, variable handling, defaults+  integration, and Tarjan SCC choice rationale. JSON encode/decode modules+  cross-reference `docs/json-format.md`.+- Filed `Primitive.implementation` carrier-simplification follow-up+  ([#446](https://github.com/CategoricalData/hydra/issues/446))+  to drop the unused `InferenceContext` and `Graph` parameters once the+  `Lib/Defaults/` integration ([#437](https://github.com/CategoricalData/hydra/issues/437))+  lands.++---++## [0.15.0] - 2026-04-29++A structural-cleanup release.+The repository is reorganized into a three-tree+`packages/` (DSL sources) / `heads/` (per-host runtime) / `dist/` (generated output)+layout ([#290](https://github.com/CategoricalData/hydra/issues/290)), the kernel is simplified ([#251](https://github.com/CategoricalData/hydra/issues/251), [#292](https://github.com/CategoricalData/hydra/issues/292), [#332](https://github.com/CategoricalData/hydra/issues/332)), and Java + Python now+ship as per-package publishable artifacts on Maven Central / PyPI / conda-forge+([#305](https://github.com/CategoricalData/hydra/issues/305)).+Incremental, content-hash-based caches accelerate the sync pipeline ([#247](https://github.com/CategoricalData/hydra/issues/247)).+Three new generation-only targets — Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)), and an+automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)) — are in progress as Claude collaborations.++### Highlights++- **Three-tree repository layout**: `packages/` (DSL), `heads/` (host runtime),+  `dist/` (generated) ([#290](https://github.com/CategoricalData/hydra/issues/290)).+- **Per-package distributions** for Java (4 Maven artifacts) and Python (5 wheels):+  `hydra-kernel`, `hydra-pg`, `hydra-rdf`, `hydra-{java,python}`, plus `hydra-ext`+  on PyPI ([#305](https://github.com/CategoricalData/hydra/issues/305)).+- **Kernel simplifications**: `Function`/`Elimination` removed ([#332](https://github.com/CategoricalData/hydra/issues/332)),+  `FunctionPrimitive` removed ([#251](https://github.com/CategoricalData/hydra/issues/251)), `Hydra.Ext.*` prefix retired ([#331](https://github.com/CategoricalData/hydra/issues/331)),+  `Context` error wrapper gone ([#292](https://github.com/CategoricalData/hydra/issues/292)).+- **Incremental caches** across the sync pipeline; ~70x speedup on no-op resync ([#247](https://github.com/CategoricalData/hydra/issues/247)).+- **JSON kernel format v1** with formal wire-format spec and four-field rename ([#343](https://github.com/CategoricalData/hydra/issues/343)).+- **Three new generation-only targets** (in progress): Coq ([#326](https://github.com/CategoricalData/hydra/issues/326)), WebAssembly ([#325](https://github.com/CategoricalData/hydra/issues/325)),+  automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324)).++### New features++- Per-package distributions ([#305](https://github.com/CategoricalData/hydra/issues/305)): standalone Maven / PyPI / conda-forge builds,+  generated `build.gradle` / `pyproject.toml` per package, transitive dep resolution.+- JSON kernel format v1 ([#343](https://github.com/CategoricalData/hydra/issues/343)): formal spec at `docs/json-format.md`,+  four-field rename to `typeScheme`, `Module` field reorder, `formatVersion` stamp.+- `decimal` literal type in the kernel ([#338](https://github.com/CategoricalData/hydra/issues/338)) across all hosts.+- Type-directed JSON encoder with idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314), [#318](https://github.com/CategoricalData/hydra/issues/318)).+- Incremental type inference plus content-hash caches ([#247](https://github.com/CategoricalData/hydra/issues/247)).+- Coq generation target ([#326](https://github.com/CategoricalData/hydra/issues/326), in progress): `hydra-coq` package, 131/131 `.v` files pass `coqc`.+- WebAssembly target ([#325](https://github.com/CategoricalData/hydra/issues/325), in progress): `hydra-wasm` package, M4 closure mechanism.+- Automatic-differentiation demo ([#324](https://github.com/CategoricalData/hydra/issues/324), in progress): symbolic source-to-source.+- `hydra.show.error` module ([#265](https://github.com/CategoricalData/hydra/issues/265)): consolidated error-message builders.+- `hydra.lib.maybes.toList` primitive ([#257](https://github.com/CategoricalData/hydra/issues/257)).+- NaN / Inf round-tripping through JSON and per-language serdes ([#312](https://github.com/CategoricalData/hydra/issues/312), [#318](https://github.com/CategoricalData/hydra/issues/318), [#330](https://github.com/CategoricalData/hydra/issues/330)).+- Typeclass inference test group ([#274](https://github.com/CategoricalData/hydra/issues/274)).+- Term and type linters ([#232](https://github.com/CategoricalData/hydra/issues/232)).+- Validation for modules and graphs ([#155](https://github.com/CategoricalData/hydra/issues/155)).+- User-defined-function (UDF) support and DSL-vs-primitive overrides+  ([#62](https://github.com/CategoricalData/hydra/issues/62), [#63](https://github.com/CategoricalData/hydra/issues/63), [#102](https://github.com/CategoricalData/hydra/issues/102), [#158](https://github.com/CategoricalData/hydra/issues/158)).+- Stale-source detection across sync entrypoints ([#228](https://github.com/CategoricalData/hydra/issues/228)).++### Improvements++- Sync infrastructure: matrix tool, per-package orchestrator, per-language wrappers ([#290](https://github.com/CategoricalData/hydra/issues/290)).+- TestGraph post-generation patches eliminated; DSL emits `TestEnv` refs directly.+- Minimized standard imports in generated Haskell ([#161](https://github.com/CategoricalData/hydra/issues/161)); improved auto-aliases ([#322](https://github.com/CategoricalData/hydra/issues/322)).+- Removed kernel term dependencies from the interpreter ([#257](https://github.com/CategoricalData/hydra/issues/257)).+- Removed `Graph` and `Context` arguments from primitive implementations ([#266](https://github.com/CategoricalData/hydra/issues/266)).+- Refactored kernel term modules: split rewriting/schemas, renamed show.meta → codegen,+  moved `Coder` to `coders`, merged `extract.helpers` ([#221](https://github.com/CategoricalData/hydra/issues/221)).+- Removed Aeson and HsYAML dependencies; YAML coder moved to `hydra-ext` ([#261](https://github.com/CategoricalData/hydra/issues/261)).+- Lisp recursive let bindings via SCC ([#341](https://github.com/CategoricalData/hydra/issues/341)); parenthesis cleanup ([#84](https://github.com/CategoricalData/hydra/issues/84)).+- Everything-to-everything bootstrapping demo ([#254](https://github.com/CategoricalData/hydra/issues/254)).+- Re-enabled skipped Python tests; `disabledForPython` retired ([#263](https://github.com/CategoricalData/hydra/issues/263)).+- Promoted host-specific code in `packages/` into per-head locations ([#337](https://github.com/CategoricalData/hydra/issues/337)).+- Migrated `hydra.common` Java module out ([#10](https://github.com/CategoricalData/hydra/issues/10)).+- Test infrastructure unification under `UniversalTestCase` ([#246](https://github.com/CategoricalData/hydra/issues/246)).+- Default property graph → RDF mapping ([#296](https://github.com/CategoricalData/hydra/issues/296)).+- 13 unsafe partial primitives replaced with `Maybe`-returning alternatives ([#201](https://github.com/CategoricalData/hydra/issues/201)).+- Java generated code uses standard `java.util` collection interfaces ([#313](https://github.com/CategoricalData/hydra/issues/313)).+- `Term.union` renamed to `Term.inject` ([#334](https://github.com/CategoricalData/hydra/issues/334)).+- Inconsistencies in domain DSLs cleaned up ([#219](https://github.com/CategoricalData/hydra/issues/219)).+- Coder packages moved out of hydra-haskell ([#182](https://github.com/CategoricalData/hydra/issues/182)).+- Java package-naming scheme revised ([#223](https://github.com/CategoricalData/hydra/issues/223)).+- Decimal used (instead of bigfloat) for JSON numbers ([#340](https://github.com/CategoricalData/hydra/issues/340)).+- Hydra kernel moved out of hydra-haskell ([#282](https://github.com/CategoricalData/hydra/issues/282)).++### Bug fixes++- `substInTypeScheme` capture-unsafe substitution under nested forall binders.+- Java `Float64` arithmetic primitives corrected for current `PrimitiveFunction` API.+- Clojure decimal handling: value-based equality, `BigInteger` return from `decimal_to_bigint`.+- Scheme runtime R7RS imports for `sets.scm` / `maps.scm` / `eithers.map_set`.+- Python coder defaults corrected from `Py.Name` to `Py.Expression`.+- Scala host JSON-decode failure on modules containing term definitions ([#342](https://github.com/CategoricalData/hydra/issues/342)).+- Lisp coder mutually-recursive let bindings for Clojure ([#341](https://github.com/CategoricalData/hydra/issues/341)).++### Documentation++- Documentation refresh for the 0.15 packaging restructure ([#290](https://github.com/CategoricalData/hydra/issues/290), [#331](https://github.com/CategoricalData/hydra/issues/331)); CLAUDE.md,+  READMEs, recipes, demos, and seven wiki pages updated.+- Code-generation recipe rewritten for the per-package dist layout ([#282](https://github.com/CategoricalData/hydra/issues/282)).+- New `maintenance.md` recipe consolidates non-source-file scans, stale generated+  detection, design-violation checks, and freshness checks.+- Documentation style guide added at `docs/documentation-style-guide.md`.+- Cross-worktree messaging protocol documented in CLAUDE.md.+- Decimal type documented in the lexicon and per-language READMEs ([#338](https://github.com/CategoricalData/hydra/issues/338)).+- JSON encoding format docs updated for idiomatic optional encoding ([#314](https://github.com/CategoricalData/hydra/issues/314)).++---++## [0.14.1] - 2026-03-30++Patch release.+Regenerates all implementations after a fix to the group eval primitive ([#281](https://github.com/CategoricalData/hydra/issues/281)),+and relocates the property-graph and RDF/SHACL "ext" modules into hydra-java and hydra-python.++### Improvements++- Moved PG, RDF, and SHACL ext modules from hydra-ext into hydra-java and hydra-python.++### Bug fixes++- Group eval primitive fix; all targets regenerated ([#281](https://github.com/CategoricalData/hydra/issues/281)).+- JavaDoc HTML-entity escaping in generated `DestructuringPattern.java`.++---++## [0.14.0] - 2026-03-29++Major release adding four new complete Hydra implementations — Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)),+Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, and Scheme — bringing the total to seven bootstrapping hosts+(plus Emacs Lisp, which passes the test suite but does not yet participate in bootstrapping).+Also includes kernel simplifications, an Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)),+eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)), new demos, and significant performance work on the Scheme host.++### Highlights++- **Four new complete implementations**: Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)), Hydra-Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)),+  Hydra-Common Lisp, and Hydra-Scheme pass the common test suite and can serve as+  bootstrapping hosts.+  The four Lisp dialects share a single coder and serializer.+- **Kernel simplifications**: removed `RowType`/`WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)),+  unified `Graph`/`TypeContext`/`InferenceContext` ([#192](https://github.com/CategoricalData/hydra/issues/192)),+  replaced `Module.elements` with `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)),+  consolidated error types ([#268](https://github.com/CategoricalData/hydra/issues/268)), and promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).+- **Avro bidirectional coder** ([#301](https://github.com/CategoricalData/hydra/issues/301)) with property graph pipeline demo.+- **Scheme bootstrap performance**: 58 minutes → 5.7 minutes via O(1) vhash data structures+  and IEEE 754 float precision fixes.++### Breaking changes++- Removed legacy adapter framework; replaced by the staging-promoted variant ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).+- Replaced legacy Flow monad with Either ([#245](https://github.com/CategoricalData/hydra/issues/245)).+- Removed `Module.elements`; use `Module.definitions` ([#214](https://github.com/CategoricalData/hydra/issues/214)).+- Removed `RowType` and `WrappedType` ([#82](https://github.com/CategoricalData/hydra/issues/82)).+- Renamed `hydra.accessors` to `hydra.paths` ([#271](https://github.com/CategoricalData/hydra/issues/271)).+- Renamed `hydra.tarjan` and merged into `hydra.sorting` ([#220](https://github.com/CategoricalData/hydra/issues/220)).+- Merged `hydra.constraints` into `hydra.query` ([#272](https://github.com/CategoricalData/hydra/issues/272)).+- Moved `hydra.workflow` to hydra-ext ([#270](https://github.com/CategoricalData/hydra/issues/270)).+- Consolidated `hydra.compute` into `hydra.util` ([#269](https://github.com/CategoricalData/hydra/issues/269)).+- Removed `hydra.describe` ([#216](https://github.com/CategoricalData/hydra/issues/216)) and types from `hydra.mantle` ([#217](https://github.com/CategoricalData/hydra/issues/217)).+- Replaced `OtherError` with task-specific error types ([#268](https://github.com/CategoricalData/hydra/issues/268)).+- Java: lowered minimum Java version to 11 ([#249](https://github.com/CategoricalData/hydra/issues/249)).+- Java: `Pair` replaces `Tuple2` ([#252](https://github.com/CategoricalData/hydra/issues/252)); `Comparable` implemented for generated classes ([#131](https://github.com/CategoricalData/hydra/issues/131)).++### New features++- Hydra-Scala ([#273](https://github.com/CategoricalData/hydra/issues/273)): complete implementation, sbt/Scala 3, 3043 tests.+- Hydra-Lisp: Clojure ([#278](https://github.com/CategoricalData/hydra/issues/278)), Common Lisp, Emacs Lisp, Scheme — four dialects,+  one coder. CI workflows for Clojure, Common Lisp, and Scheme.+- Avro bidirectional coder ([#301](https://github.com/CategoricalData/hydra/issues/301)) with demo.+- Eval primitives ([#281](https://github.com/CategoricalData/hydra/issues/281)): Logic, Equality, Math, collections, and Groups.+- Generated DSL modules ([#180](https://github.com/CategoricalData/hydra/issues/180)): `hydra.dsls` generates DSL helpers from type modules.+- New demos: GraphQL+JSON ([#279](https://github.com/CategoricalData/hydra/issues/279)), PG validation ([#284](https://github.com/CategoricalData/hydra/issues/284)), SHACL ([#294](https://github.com/CategoricalData/hydra/issues/294)), Avro+PG.+- Packaging module ([#290](https://github.com/CategoricalData/hydra/issues/290)): `hydra.packaging` with `Package` type and validation.+- New primitives: `lists.foldr` ([#280](https://github.com/CategoricalData/hydra/issues/280)), `maybes.toList`, float rounding ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).+- Cross-language benchmarking suite ([#234](https://github.com/CategoricalData/hydra/issues/234)).+- Limited typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)).+- Standardized validation patterns across modules ([#291](https://github.com/CategoricalData/hydra/issues/291)).++### Improvements++- Promoted all staging modules to DSL sources ([#267](https://github.com/CategoricalData/hydra/issues/267)).+- Removed legacy adapters, JSON/YAML coders, grammar framework ([#236](https://github.com/CategoricalData/hydra/issues/236), [#295](https://github.com/CategoricalData/hydra/issues/295)).+- Java: efficient immutable data structures ([#193](https://github.com/CategoricalData/hydra/issues/193)); flattened term naming.+- Java: hidden specialized collection classes in type-level files ([#313](https://github.com/CategoricalData/hydra/issues/313)).+- Inference error messages improved ([#231](https://github.com/CategoricalData/hydra/issues/231)).+- Combined nested let bindings in the Haskell coder ([#248](https://github.com/CategoricalData/hydra/issues/248)).+- Simplified `hydra.adapt.simple` ([#255](https://github.com/CategoricalData/hydra/issues/255)).+- Removed Haskell operators dependency from tests ([#288](https://github.com/CategoricalData/hydra/issues/288)).+- Regression tests for non-Haskell/Java coders ([#85](https://github.com/CategoricalData/hydra/issues/85)).+- Regex support added ([#293](https://github.com/CategoricalData/hydra/issues/293)).+- `hydra.annotations.isNativeType` revisited ([#214](https://github.com/CategoricalData/hydra/issues/214)).+- Migrated grammar-generated models ([#295](https://github.com/CategoricalData/hydra/issues/295)).+- `<<= -shouldBe-> <<~` operator change ([#276](https://github.com/CategoricalData/hydra/issues/276)).+- Minimize Generation.hs ([#225](https://github.com/CategoricalData/hydra/issues/225)).+- Implemented missing Flows primitives ([#183](https://github.com/CategoricalData/hydra/issues/183)).+- Removed JavaDocs from the repository ([#262](https://github.com/CategoricalData/hydra/issues/262)).+- Floating-point test portability fixes for Linux CI ([#264](https://github.com/CategoricalData/hydra/issues/264), [#285](https://github.com/CategoricalData/hydra/issues/285)).+- Moved YAML coder to hydra-ext ([#224](https://github.com/CategoricalData/hydra/issues/224)).+- Minimized native Python and Java primitives in favor of DSL implementations ([#244](https://github.com/CategoricalData/hydra/issues/244)).+- Removed the `disabledForPython` test tag ([#250](https://github.com/CategoricalData/hydra/issues/250)).++### Release tooling++- 0.14 release tracking ([#304](https://github.com/CategoricalData/hydra/issues/304)).++### Documentation++- Thorough cleanup of user documentation ([#302](https://github.com/CategoricalData/hydra/issues/302), [#303](https://github.com/CategoricalData/hydra/issues/303)).+- Coding style guide added to wiki.+- Updated 'new implementation' recipe with learnings from Clojure head ([#278](https://github.com/CategoricalData/hydra/issues/278)).++---++## [0.13.0] - 2026-02-27++Major release completing Hydra-Python ([#66](https://github.com/CategoricalData/hydra/issues/66)) and Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)) as self-hosting Hydra implementations+and demonstrating mutual self-hosting across all three languages.+Significant improvements to type inference, type checking, rewriting, and adaptation.+New language features include first-class Either types, typeclass inference, binary data support,+and a native JSON parser/writer.+Comprehensive tooling for cross-implementation bootstrapping+and provisional support for Go, Rust, and JavaScript targets.++### Highlights++- **Mutual self-hosting across three implementations**: Hydra is now fully self-hosting+  in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)), Java, and Python, and can cross-generate between every combination+  of host and target language (9 paths total).+- **Hydra-Java is complete** ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass.+- **Hydra-Python is complete** ([#66](https://github.com/CategoricalData/hydra/issues/66)): 100% test parity with Haskell.+- **Language coders promoted into the Hydra kernel** ([#176](https://github.com/CategoricalData/hydra/issues/176)): Haskell, Java, and Python+  coders are now defined as Hydra DSL modules, making them self-hosting.+- **Either type support** ([#210](https://github.com/CategoricalData/hydra/issues/210)) with full inference, checking, and library support.+- **Native JSON parser and writer** ([#188](https://github.com/CategoricalData/hydra/issues/188), [#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)): Hydra's own JSON parser and writer+  replace the Aeson dependency; bootstrap-from-JSON architecture for cross-implementation+  code generation.++### Breaking changes++- Renamed `Optional` to `Maybe` throughout the codebase ([#204](https://github.com/CategoricalData/hydra/issues/204)):+  `hydra.lib.optionals` → `hydra.lib.maybes`; all `optional` variants renamed to `maybe`.+- Removed unlabeled product and sum types; replaced with pair types ([#212](https://github.com/CategoricalData/hydra/issues/212)).+- Renamed `hydra.core.TypedTerm` to `hydra.core.TypeApplicationTerm`.+- Renamed `hydra.json` to `hydra.json.model`.+- Renamed `hydra.lib.maps.remove` to `hydra.lib.maps.delete`.+- Removed deprecated `hydra.decoding` module.+- Removed old `hydra.mantle.Either` type (replaced by core `Either`).+- Removed `hydra.lib.tuples` library.+- Removed C# coder stub (C# syntax model remains).+- DSL syntax migration: removed `OverloadedStrings` for term expressions ([#238](https://github.com/CategoricalData/hydra/issues/238)).+- Removed `Hydra.Dsl.ShorthandTypes` ([#222](https://github.com/CategoricalData/hydra/issues/222)).++### New features++- Self-hosting in Haskell ([#179](https://github.com/CategoricalData/hydra/issues/179)) and full mutual cross-generation (Haskell ↔ Java ↔ Python).+- New bootstrapping demo validating all 9 paths across 249 modules.+- Promoted Haskell, Java, and Python coders from staging code into Hydra DSL sources ([#176](https://github.com/CategoricalData/hydra/issues/176)).+- JSON-as-source-of-truth bootstrapping architecture ([#243](https://github.com/CategoricalData/hydra/issues/243), [#253](https://github.com/CategoricalData/hydra/issues/253)):+  new executables and scripts enabling `bootstrap-from-json` for cross-implementation+  code generation.+- Generated term encoders and decoders replace legacy hand-coded modules ([#47](https://github.com/CategoricalData/hydra/issues/47)).+- Hydra-Python completion ([#66](https://github.com/CategoricalData/hydra/issues/66)): restructured project layout with `src/main` and+  `src/gen-main` ([#191](https://github.com/CategoricalData/hydra/issues/191)); full library implementations including `hydra.lib.flows`;+  `@lru_cache` optimization for nullary bindings; PyPy compatibility.+- Hydra-Java completion ([#166](https://github.com/CategoricalData/hydra/issues/166)): all kernel and generation tests pass; deep changes+  to Java coder; `Lazy` utility class for delayed evaluation; array-type support+  in Java serde; tail-call optimization in the Java coder; `Tuple` implements `Comparable`.+- Either type ([#210](https://github.com/CategoricalData/hydra/issues/210)): `EitherType`, `either` term constructor, `hydra.lib.eithers` library+  with `either`, `map`, `mapList`, `mapMaybe`, `bimap`, `bind`, `fromLeft`, `fromRight`,+  `isLeft`, `isRight`, `lefts`, `rights`, `partitionEithers`.+- Pair type as a core construct ([#211](https://github.com/CategoricalData/hydra/issues/211)).+- Void type ([#237](https://github.com/CategoricalData/hydra/issues/237)): uninhabited `void` type as the dual of `unit`; type-level only.+- Native JSON parser and writer ([#188](https://github.com/CategoricalData/hydra/issues/188), [#242](https://github.com/CategoricalData/hydra/issues/242)):+  bidirectional JSON encoder/decoder; replaces the Aeson dependency;+  cross-checked via a special test runner.+- Typeclass inference ([#164](https://github.com/CategoricalData/hydra/issues/164)):+  type schemes with typeclass constraints via `TypeVariableMetadata`;+  typeclass metadata on primitive definitions; Haskell coder uses typeclass info.+- Binary/`ByteString` support ([#172](https://github.com/CategoricalData/hydra/issues/172)): binary data via `ByteString` instead of `String`;+  Haskell coder uses `Data.ByteString`; new `binaryToBytes` primitive.+- Parser combinators: new `hydra.parsing` module with combinator types and DSL.+- Higher-order primitive interpreter ([#198](https://github.com/CategoricalData/hydra/issues/198)): all primitives are fully interpretable+  across all three implementations; legacy `requiresInterp` tag removed.+- Let hoisting and flattening: hoisting polymorphic let terms;+  refined hoisting for monomorphic bindings inside polymorphic ones;+  more efficient `liftLambdaAboveLet` ([#202](https://github.com/CategoricalData/hydra/issues/202));+  case-statement hoisting ([#241](https://github.com/CategoricalData/hydra/issues/241)); subterm hoisting helpers.+- Provisional language targets: Go ([#65](https://github.com/CategoricalData/hydra/issues/65)), Rust (with experimental type-level coder),+  JavaScript (syntax model, serde, DSL, generated sources), and Java/Python syntax DSLs.+- New adapter framework ([#236](https://github.com/CategoricalData/hydra/issues/236)): all external coders refactored+  (Haskell, YAML, Scala, JSON Schema, C++, PDL, Protobuf, GraphQL).+- Compact labeled records and variants ([#122](https://github.com/CategoricalData/hydra/issues/122)).+- New primitives:+  `hydra.lib.lists.find`, `hydra.lib.lists.partition`,+  `hydra.lib.flows.withDefault`, `hydra.lib.flows.foldl`,+  `hydra.lib.math.{max,min,abs,pred,signum,succ,even,odd}`,+  `hydra.lib.pairs.bimap`, `hydra.lib.eithers.bind`,+  `hydra.lib.literals.binaryToBytes`, complete `readXxx`/`showXxx` families,+  `hydra.lexical.chooseUniqueName`, `neg` renamed to `negate`,+  full floating-point math primitives in Python ([#208](https://github.com/CategoricalData/hydra/issues/208)).+- DeepCore DSL: a layer one level deeper than the Meta DSLs,+  for programs that construct programs that construct terms.+- `typeOf` implementation ([#168](https://github.com/CategoricalData/hydra/issues/168)).+- Implement `Comparable` for generated Java classes ([#131](https://github.com/CategoricalData/hydra/issues/131)); update of Hydra-Java ([#166](https://github.com/CategoricalData/hydra/issues/166)).+- Compact labeled records exploration ([#122](https://github.com/CategoricalData/hydra/issues/122)).+- Comparison primitives without typeclasses ([#187](https://github.com/CategoricalData/hydra/issues/187)).+- Investigated core support for Either and Flow monads ([#200](https://github.com/CategoricalData/hydra/issues/200)).++### Improvements++- Type system:+  - Refactored `hydra.inference` to create new module `hydra.checking`.+  - Inference checks after unification to prevent schema names from being unified+    with inferred type variables.+  - Type application terms preserved when preparing application terms for Python.+  - Sanity-check tuple projection index against arity during inference.+  - Bind lost type variables in term annotations.+  - Made `extendTypeContextForLet` tolerant of untyped bindings.+- Code generation:+  - Python: support for deeply-nested match statements; more complete `let` support;+    Pythonic syntax for polymorphic function definitions; refinements for complex+    case-hoisting scenarios; performance improvements ([#209](https://github.com/CategoricalData/hydra/issues/209), [#239](https://github.com/CategoricalData/hydra/issues/239), [#240](https://github.com/CategoricalData/hydra/issues/240)); inline+    let/case rewriting for Python targets ([#203](https://github.com/CategoricalData/hydra/issues/203)).+  - Java: method declaration style consistent with calling style.+  - Haskell: standardized typeclass names.+  - Increased maximum trace depth to support more complex sources.+- Common test suite promotion: all tests promoted into a shared, implementation-independent+  test kernel ([#213](https://github.com/CategoricalData/hydra/issues/213)).+- Statically-compiled test suite in Haskell ([#207](https://github.com/CategoricalData/hydra/issues/207)).+- Included all Hydra kernel types in test schema ([#205](https://github.com/CategoricalData/hydra/issues/205)).+- Reorganized Haskell DSL definitions; standardized imports.+- Added TODO comments to all unsafe primitives ([#201](https://github.com/CategoricalData/hydra/issues/201)).+- New `rewriteAndFoldTerm` utility for simultaneous rewriting and folding.+- Lexical helper for dereferencing schema types through aliases.+- Made JSON parser lazy with new `lazy` parser combinator.+- More efficient substitution helpers for empty substitutions.+- Precomputed type/inference context in kernel test runner for performance.+- Property graph encoding and decoding modules promoted into DSL.+- `hydra.tabular` and `hydra.pg.graphson` modules promoted into DSL.+- `hydra.show.*` modules generated into Java and Python.+- Aligned epsilon encoding with the LambdaGraph spec ([#89](https://github.com/CategoricalData/hydra/issues/89)).+- Fixed asymmetry of introductions and eliminations ([#86](https://github.com/CategoricalData/hydra/issues/86), [#134](https://github.com/CategoricalData/hydra/issues/134)).+- Minimized inferred type annotations ([#114](https://github.com/CategoricalData/hydra/issues/114)).+- Investigated combining products with records, sums with unions ([#196](https://github.com/CategoricalData/hydra/issues/196), [#212](https://github.com/CategoricalData/hydra/issues/212)).+- Refined type reduction in adapters ([#144](https://github.com/CategoricalData/hydra/issues/144)).+- Investigation of unification issues ([#163](https://github.com/CategoricalData/hydra/issues/163)).+- Refactored RowType ([#82](https://github.com/CategoricalData/hydra/issues/82)).+- LLM-assisted PG schemas and mappings ([#171](https://github.com/CategoricalData/hydra/issues/171)).+- Simplified unit-valued variants in Python ([#206](https://github.com/CategoricalData/hydra/issues/206)).+- Checked for inconsistencies between Term/TTerm and Type/TType DSLs ([#218](https://github.com/CategoricalData/hydra/issues/218)).+- GenPG demo: refactored to support Haskell, Python, and Java; Python runner;+  Java generation; finalized output format.+- Testing: extended test runners for let hoisting (Haskell, Python, Java);+  floating-point precision tests; ordering tests for `hydra.lib.maps`/`hydra.lib.sets`;+  inference tests for inferred System F terms; case-hoisting test cases; new JSON coder tests;+  thorough test cases for all primitives ([#199](https://github.com/CategoricalData/hydra/issues/199)).++### Bug fixes++- Fixed interpreter bugs causing test failures ([#235](https://github.com/CategoricalData/hydra/issues/235)).+- Fixed bug in type checking in connection with dead code.+- Fixed bug in `removeTypesFromTerm`.+- Fixed bug in `typeOfMap`.+- Fixed 32-bit max int value in `hydra.constants`.+- Fixed numeric precision in Python.+- Added `BigDecimal` support and fixed `uint8` (short) support in Java.+- Fixed Haskell coder with respect to imports for binary literals.+- Excluded `Prelude.encodeFloat` and `Prelude.decodeFloat` from generated Haskell+  due to name collisions.+- Fixed consistency issues in Python primitives:+  `hydra.lib.sets.toList`, `hydra.lib.maps.union` (precedence),+  `hydra.lib.strings.lines`, `hydra.lib.strings.readString` (dequoting),+  `hydra.lib.lists.apply`, `hydra.lib.maps.toList`.+- Fixed Haskell type signature of `hydra.lists.span`.+- Fixed issue with eta expansion of typed terms.+- Fixed shadowing issue in generated encoding modules.+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.++### Documentation++- Updated main README with complete implementation status.+- Added Documentation sections to all implementation READMEs.+- Fixed outdated Code-organization.md (Python now uses `src/gen-main`).+- Fixed incorrect code paths in Implementation.md.+- Added Java section to Testing wiki.+- Comprehensive developer recipes in `docs/recipes/`.+- Documentation for tail-call optimization implementation.+- Added Haddock comments to Haskell primitives.+- Created wiki page on the release process ([#194](https://github.com/CategoricalData/hydra/issues/194)).++### Community++- Accepted babeloff's `isTrivialTerm` changes.++---++## [0.12.0] - 2025-08-28++A consolidation release: significant Python progress, kernel-level cleanup,+and a wave of bookkeeping closures for Hydra-Java module ports.++### Breaking changes++- Removed `hydra.decoding` module ([#190](https://github.com/CategoricalData/hydra/issues/190)).+- Flattened dependency tiers; eliminated tier-1, tier-2, tier-3 organization ([#184](https://github.com/CategoricalData/hydra/issues/184)).+- Removed `typed` term variant ([#173](https://github.com/CategoricalData/hydra/issues/173), [#162](https://github.com/CategoricalData/hydra/issues/162)).+- Module naming changes: moved tabular and relational modules into kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).+- Standardized on uncurried helper functions in term-level DSLs ([#174](https://github.com/CategoricalData/hydra/issues/174)).+- Renamed `hydra.lib.flows.traverseOptional` to `hydra.lib.flows.mapOptional`.+- Eliminated camel-cased namespace parts from the kernel ([#152](https://github.com/CategoricalData/hydra/issues/152)).+- Replaced list and optional eliminations with primitive functions ([#150](https://github.com/CategoricalData/hydra/issues/150)).+- Moved `Hydra.Ext` to hydra-ext ([#178](https://github.com/CategoricalData/hydra/issues/178)); moved 'ext' sources into hydra-ext ([#189](https://github.com/CategoricalData/hydra/issues/189)).++### New features++- Significant progress toward Hydra-Python completion:+  generated all kernel types and terms into Python;+  added `Decimal` support for bigfloat values;+  environment tracking for variable scoping;+  generated `hydra.languages` into Python;+  `__hash__` and `__eq__` on serializable generated classes ([#160](https://github.com/CategoricalData/hydra/issues/160)).+- Designated `unit` term and type variants ([#186](https://github.com/CategoricalData/hydra/issues/186)).+- `hydra.lib.flows.mapElems` and `hydra.lib.flows.mapKeys` utilities.+- Promoted JSON coder into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).+- Promoted JSON utilities into the DSL ([#181](https://github.com/CategoricalData/hydra/issues/181)).+- C# coder ([#139](https://github.com/CategoricalData/hydra/issues/139)).+- GQL model and parser ([#140](https://github.com/CategoricalData/hydra/issues/140)).+- Tabular adapters ([#142](https://github.com/CategoricalData/hydra/issues/142)).+- Type-level C++ coder ([#170](https://github.com/CategoricalData/hydra/issues/170)).+- Variable-types-to-Haskell-typedefs transformation ([#70](https://github.com/CategoricalData/hydra/issues/70)).+- A newline at the end of each generated file ([#154](https://github.com/CategoricalData/hydra/issues/154)).+- Refactor kernel modules and primitives by connectivity ([#177](https://github.com/CategoricalData/hydra/issues/177)).++### Improvements++- Condensed repeated elements in error traces ([#165](https://github.com/CategoricalData/hydra/issues/165)).+- Fixed transitive schema dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).+- Improved adapter solution with respect to literals.+- Better handling of type variables in Python coder.+- Enhanced term-level Python generation with proper ordering to minimize forward references.+- Topo-sort helper function for dependency management.+- Updated all Python libraries with latest changes.+- Distinguished between deannotation and detyping of terms.+- Adapted primitives when applying language constraints to a graph.+- Use unqualified names where possible in generated code ([#153](https://github.com/CategoricalData/hydra/issues/153)).+- Eliminated `Data.Graph` (containers) dependency ([#167](https://github.com/CategoricalData/hydra/issues/167)).+- "Close the loop" demonstration ([#175](https://github.com/CategoricalData/hydra/issues/175)).+- Implemented `typeOf` ([#168](https://github.com/CategoricalData/hydra/issues/168)).++### Bug fixes++- Fixed System F terms for records and case statements ([#168](https://github.com/CategoricalData/hydra/issues/168)).+- Fixed issue with transitive type-level module dependencies ([#185](https://github.com/CategoricalData/hydra/issues/185)).+- Corrected handling of variable references in Python application terms.+- Fixed nullary functions in Python (added empty parens).+- Added missing alternatives in `hydra.rewriting.rewriteTermM`.++### Bookkeeping++- Closed long-standing Hydra-Java module-port issues+  ([#9](https://github.com/CategoricalData/hydra/issues/9), [#11](https://github.com/CategoricalData/hydra/issues/11), [#15](https://github.com/CategoricalData/hydra/issues/15), [#16](https://github.com/CategoricalData/hydra/issues/16), [#18](https://github.com/CategoricalData/hydra/issues/18), [#19](https://github.com/CategoricalData/hydra/issues/19), [#20](https://github.com/CategoricalData/hydra/issues/20), [#21](https://github.com/CategoricalData/hydra/issues/21), [#22](https://github.com/CategoricalData/hydra/issues/22), [#23](https://github.com/CategoricalData/hydra/issues/23), [#25](https://github.com/CategoricalData/hydra/issues/25), [#44](https://github.com/CategoricalData/hydra/issues/44), [#45](https://github.com/CategoricalData/hydra/issues/45));+  most of the underlying work shipped in earlier releases.+- Closed Hydra-Java DSL-port issues ([#24](https://github.com/CategoricalData/hydra/issues/24), [#26](https://github.com/CategoricalData/hydra/issues/26), [#27](https://github.com/CategoricalData/hydra/issues/27), [#28](https://github.com/CategoricalData/hydra/issues/28), [#29](https://github.com/CategoricalData/hydra/issues/29)) and+  the Scala/Avro tracking issues ([#77](https://github.com/CategoricalData/hydra/issues/77), [#81](https://github.com/CategoricalData/hydra/issues/81)); these had been resolved+  by earlier releases (Scala in 0.14.0, Avro bidi in 0.14.0).++### Documentation++- Updated Hydra-Haskell README.+- Updated Hydra-Java README with corrected links.+- Updated JavaDocs.++---++## [0.11.0] - 2025-03-16++Untagged in-repository version.+A type-inference rebase release: major restructuring of inference internals+to align with Algorithm W, plus a sweeping removal of explicit type annotations+across the kernel.++### Highlights++- **Inference rebased on Algorithm W** ([#118](https://github.com/CategoricalData/hydra/issues/118)): unify-early strategy ([#146](https://github.com/CategoricalData/hydra/issues/146)),+  infinite-type checks restored ([#116](https://github.com/CategoricalData/hydra/issues/116)), recursive-element inference ([#90](https://github.com/CategoricalData/hydra/issues/90)),+  unified handling of elements and let bindings ([#112](https://github.com/CategoricalData/hydra/issues/112)), minimized manual+  type annotations ([#119](https://github.com/CategoricalData/hydra/issues/119)).+- **`hydra.inference` module** introduced for inference type definitions;+  substitution and unification moved up a level.++### Breaking changes++- Argument order of `Logic.ifElse` changed ([#147](https://github.com/CategoricalData/hydra/issues/147)).++### New features++- Inference test cases promoted into the common test suite ([#148](https://github.com/CategoricalData/hydra/issues/148));+  added "kernel examples" inference tests; more recursion / mutual recursion cases.++### Improvements++- Removed type annotations across all kernel sources ([#119](https://github.com/CategoricalData/hydra/issues/119)).+- Migrated to fully-applied primitive library DSLs ([#157](https://github.com/CategoricalData/hydra/issues/157)).+- Aligned `Graph` and `Element` with `LetBinding` ([#159](https://github.com/CategoricalData/hydra/issues/159)).+- `hydra.core.Unit` recognized by the Haskell coder.+- Refactored inference tests.++### Bug fixes++- Fix for underdetermined type in `hydra.decode`.++---++## [0.10.0] - 2025-02-19++Untagged in-repository version.+Adds Hydra-Python (initial completion), a GraphSON coder,+provisional Hydra-Go support, and dot-separated namespace conventions.++### Highlights++- **Hydra-Python initial completion** ([#80](https://github.com/CategoricalData/hydra/issues/80), [#66](https://github.com/CategoricalData/hydra/issues/66)): Python coder, generated kernel+  modules in Python, and full library implementations across kernel namespaces.+- **GraphSON coder** ([#79](https://github.com/CategoricalData/hydra/issues/79)).+- **Provisional Hydra-Go** ([#65](https://github.com/CategoricalData/hydra/issues/65)).+- **Namespace formatting** standardized to dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).++### Breaking changes++- All namespaces use dot-separated form ([#151](https://github.com/CategoricalData/hydra/issues/151)).++### New features++- Hydra-Python: Python coder; generated `hydra.coreEncoding`, `hydra.strip`,+  `hydra.literals` and other kernel modules in Python; tuple-expression support;+  updated `hydra.constants` in Python.+- GraphSON coder ([#79](https://github.com/CategoricalData/hydra/issues/79)).+- Provisional Hydra-Go ([#65](https://github.com/CategoricalData/hydra/issues/65)).+- `string-to-char-list` and `char-list-to-string` primitives ([#149](https://github.com/CategoricalData/hydra/issues/149)).+- Restored normalization for generated term variables ([#145](https://github.com/CategoricalData/hydra/issues/145)).++### Improvements++- Re-leveled dependency tiers ([#135](https://github.com/CategoricalData/hydra/issues/135)).+- Updated all Java, Haskell, hydra-ext, and Python primitives to current sources.++---++## [0.9.0] - 2025-01-06++Untagged in-repository version.+Bootstraps Hydra-Python and the JSON Schema coder; introduces a fluent Java DSL for flows.++### Highlights++- **JSON Schema coder** ([#141](https://github.com/CategoricalData/hydra/issues/141)).+- **Python coder scaffold**: serde, language constraints, and generated Haskell+  sources for Python.+- **Fluent-style Java DSL for flows** ([#143](https://github.com/CategoricalData/hydra/issues/143)).++### New features++- JSON Schema coder ([#141](https://github.com/CategoricalData/hydra/issues/141)).+- Python coder scaffold and serde.+- Provisional Python language constraints module.+- Fluent-style Java DSL for flows ([#143](https://github.com/CategoricalData/hydra/issues/143)); moved Flows DSL into `hydra.dsl`.+- New `hydra.coders` DSL.+- New DSL functions for core variants.++### Improvements++- Generalized `Namespaces` so it can be used for languages other than Haskell.+- Local-name-only Python type aliases (the directory tree provides the namespace).+- Coders DSL used to simplify Java language-constraint sources.+- Removed redundant productions in the Python grammar.+- Added unit tests for fluent flows.++### Documentation++- Updated JavaDocs for 0.9.0.++---++## [0.8.1] - 2024-09-24++Patch release.++### Improvements++- Generalized the property graph merging utility to accept type systems other than Hydra Core.++---++## [0.8.0] - 2024-09-09++C# support ([#139](https://github.com/CategoricalData/hydra/issues/139)), Graphviz DOT coder, term accessors, and a small breaking change in Java+to support Spark.++### Breaking changes++- Made `FlowException` serializable for Spark support (may affect existing error handling).++### New features++- C# syntax module based on the Microsoft ANTLR grammar ([#139](https://github.com/CategoricalData/hydra/issues/139)).+- Graphviz DOT coder ([#136](https://github.com/CategoricalData/hydra/issues/136)):+  full support for lambdas and recursive `let` statements;+  compact 'accessor graph' visualization option;+  customizable label styles;+  highlighted let-bound terms; edge labels.+- Term accessor type to facilitate lenses and path-aware transformations.+- OpenGQL grammar and generated Haskell for the OpenGQL model ([#140](https://github.com/CategoricalData/hydra/issues/140)).++### Improvements++- Added `</>` as alternative to `@@` application operator in Haskell DSLs.+- Utilities for working with term accessors.+- More specific exception class for JSON decoding.+- Additional convenience methods on `JsonDecoding.java`.+- Used transitive dependencies in hydra-java and hydra-ext.+- Upgraded ANTLR to address a vulnerability.+- Moved TinkerPop utilities from `hydra/ext/org/apache/tinkerpop` into `hydra/pg`.++---++## [0.7.0] - 2024-08-21++Major refactoring of module organization and namespace management.+Establishes the DNS-style namespace convention in hydra-ext+and lifts property-graph models into a top-level `hydra/pg` namespace.++### Breaking changes++- Namespace reorganization: migrated to DNS-based module naming in hydra-ext ([#138](https://github.com/CategoricalData/hydra/issues/138)):+  `hydra/ext/avro` → `hydra/ext/org/apache/avro`,+  `hydra/ext/graphql` → `hydra/ext/org/graphql`,+  `hydra/ext/yaml` → `hydra/ext/org/yaml`,+  `hydra/ext/json/decoding` → `hydra/ext/org/json/decoding`,+  `hydra/ext/rdf` → `hydra/ext/org/w3/rdf`,+  `hydra/ext/shacl` → `hydra/ext/org/w3/shacl`,+  `hydra/ext/tinkerpop` → `hydra/ext/org/apache/tinkerpop`.+- Property graphs: promoted property graph modules from+  `hydra/ext/org/apache/tinkerpop` to `hydra/pg`.+- Project structure: renamed `hydra-extensions` to `hydra-ext`;+  renamed `hydra/langs` to `hydra/ext` ([#138](https://github.com/CategoricalData/hydra/issues/138));+  made hydra-ext into a Gradle subproject alongside hydra-java;+  added top-level Gradle build.++### Improvements++- Moved TinkerPop modules from hydra-haskell into hydra-ext for better separation.+- Moved miscellaneous models to `Hydra.Ext.Other` ([#138](https://github.com/CategoricalData/hydra/issues/138)).+- Moved XML Schema, SQL, ShEx, and OWL models to hydra-ext.+- Moved KQL, Parquet, and Python modules to hydra-ext.+- Separated JavaDocs for hydra-java and hydra-ext.+- Updated publishing configuration in `build.gradle`.++---++## [0.6.0] - 2024-08-19++Type-system improvements (System F type abstraction/application; eliminated polymorphic+types from Hydra Core), expanded language support (Graphviz DOT model, generated Java+field-name constants), and revamped annotation handling.++### Breaking changes++- Eliminated `InferenceContext` helper type ([#103](https://github.com/CategoricalData/hydra/issues/103)).+- Changed typing environment from `Map Name Type` to `Map Name TypeScheme` in graphs ([#76](https://github.com/CategoricalData/hydra/issues/76)).+- Updated annotations and flows to use `map<Name, Term>` instead of `map<string, Term>` ([#133](https://github.com/CategoricalData/hydra/issues/133)).+- Unified `Name` and `FieldName`; aliased to `string` ([#121](https://github.com/CategoricalData/hydra/issues/121)).+- Renamed `hydra/core.UnitType` to `hydra/core.Unit` ([#123](https://github.com/CategoricalData/hydra/issues/123)).+- Eliminated annotation classes; Hydra has a single built-in notion of annotations ([#113](https://github.com/CategoricalData/hydra/issues/113)).+- Unified the `Nominal` type with `RowType` ([#115](https://github.com/CategoricalData/hydra/issues/115)).+- Removed the `extends` parameter for row types ([#132](https://github.com/CategoricalData/hydra/issues/132)).+- Replaced `hydra/Kv` with `hydra/Annotations` (rename revisited).++### New features++- System F support: `typeAbstraction` and `typeApplication` term constructors.+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).+- Graphviz DOT model and initial support ([#136](https://github.com/CategoricalData/hydra/issues/136)).+- Field-name constants generated in Java code generation ([#137](https://github.com/CategoricalData/hydra/issues/137)).+- Provisional Algorithm W implementation in Haskell (originally from @wisnesky), kept for reference.++### Improvements++- Primitive organization: Hydra primitives organized into libraries for namespace management.+- Code generation:+  - Escaped field name constants and `with_` methods in Java coder.+  - Generated field name constants in Java ([#137](https://github.com/CategoricalData/hydra/issues/137)).+  - Avoided duplicated comments in wrapper classes in generated Java.+  - Removed superfluous newtype comments in Haskell coder.+- Updated Delta Parquet model to follow the Java API more closely.+- Enriched OpenCypher features module with the complete list of standard Cypher functions.+- Added convenience methods to `JsonEncoding.java`.+- Restored `Hydra.Inference` subdirectory.+- Allowed arbitrary case for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).+- Corrected `uint8` representation in Java to `Short` ([#120](https://github.com/CategoricalData/hydra/issues/120)).++### Bug fixes++- Fixed handling of type annotations in term adapters.+- Fixed decoding of encoded terms annotated with a type.+- Corrected encoding of universal types in `showTerm` ([#117](https://github.com/CategoricalData/hydra/issues/117)).++---++## [0.5.3] - 2024-08-06++Patch release.+Preserves order of map key/value pairs and set elements during JSON serialization.++### Bug fixes++- Preserved ordering of key/value pairs and set elements in JSON output.++### New features++- Polymorphic `equal` primitive in Haskell and Java.+- Generated Hydra type definitions together with native instantiations of Hydra types+  in Haskell (a stepping stone toward generated coders, [#47](https://github.com/CategoricalData/hydra/issues/47)).++---++## [0.5.1] - 2024-08-01++Patch release.+Dependency updates and minor improvements following the 0.5.0 Hydra Core overhaul.++### Improvements++- Updated dependencies.++---++## [0.5.0] - 2024-07-26++Untagged in-repository version.+Major Hydra Core overhaul: eliminates polymorphic types in favor of explicit+TypeScheme; consolidates the annotation system; revamps `Let` term encoding.++### Breaking changes++- Eliminated polymorphic types from Hydra Core in Haskell ([#125](https://github.com/CategoricalData/hydra/issues/125)):+  removed type parameters from `hydra/core` types in Hydra-Java; replaced type schemes+  with forall types ([#76](https://github.com/CategoricalData/hydra/issues/76)).+- Revamped core encoding and `Let`: bindings are now a list of+  `(name, term, optional type scheme)` triplets instead of a map.+- Unified typed-term types and moved `TypeScheme` into Hydra Core.+- Eliminated `AnnotationClass`; Hydra has a single built-in notion of annotations now ([#113](https://github.com/CategoricalData/hydra/issues/113)).+- Renamed and refactored phantom-type wrappers ([#128](https://github.com/CategoricalData/hydra/issues/128)); removed deprecated `Reference`+  type from `hydra/phantoms`.+- Removed incomplete support for stream types and stream terms ([#88](https://github.com/CategoricalData/hydra/issues/88)).++### New features++- `LiteralTypes` DSL module so literals can be built independently of terms.+- `Hydra.Minimal` module to facilitate collaboration on Hydra application prototypes.+- `TypeConstraint` type added to the kernel.+- `foldl` primitive in Haskell and Java; DSL uses `foldl` instead of the built-in+  list elimination term by default.++### Improvements++- Improvements to Java and JSON coders; improved untyped JSON coder.+- Pre-order and post-order term-traversal test cases added.+- Refactored type inference tests.+- Restored generated Java (Core through Tier 3) with only a few manual tweaks.+- Element names allow arbitrary case ([#7](https://github.com/CategoricalData/hydra/issues/7)).++---++## [0.4.0] - 2024-07-10++Untagged in-repository version.+Adds null checks to generated Java (breaking, but justified — Hydra-Java disallows nulls),+the Gremlin model, and Protobuf annotation refinements.++### Breaking changes++- Null checks added to constructors and `withXXX()` methods in generated Java;+  null values are no longer permitted in Hydra-Java.+- Removed Java 8 restriction (raised minimum Java version).++### New features++- Gremlin model ([#127](https://github.com/CategoricalData/hydra/issues/127)); generated Haskell for Gremlin.+- `hydra/lib/lists.safeHead` primitive in Haskell (necessary in Java due to eager evaluation).+- Support for Protobuf `deprecated=true` annotation; non-string Protobuf options.+- Java options in generated Protobuf.++### Improvements++- Used `java.util.Objects.requireNonNull` instead of a custom null check in generated Java.+- Added 'automatically generated file' disclaimer to generated Java files.+- Added autogen comments and null checks to (most) generated Java.+- Added necessary schema-level dependencies for built-in modules.+- Added null checks to the Flows DSL in Java.++---++## [0.3.0] - 2024-06-05++Untagged in-repository version.+Adds an OpenCypher parser based on an ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124)),+a KQL (Kusto Query Language) model and serializer,+a Delta Parquet model,+and an early property graph queries model in the style of Cypher.++### New features++- OpenCypher parser based on the OpenCypher M23 ANTLR grammar ([#124](https://github.com/CategoricalData/hydra/issues/124));+  ANTLR added as a build dependency;+  large Cypher test suite drawn from the Cypher Manual.+- Cypher-to-PG-query transformer (Java; partially implemented).+- Property graph queries DSL and generated property graph query classes in Java.+- Property graph queries model (Cypher / future GQL style).+- KQL (Kusto Query Language) initial model and basic serializer.+- Delta Parquet model with generated sources.++### Improvements++- Java options and `deprecated=true` support in generated Protobuf.+- Convenience methods in Java.++---++## [0.2.0] - 2024-01-10++Hydra-Java 0.2.0 release.+Significant Java tooling and DSL build-out, Protobuf bidirectional coder,+Python3 syntax model ([#80](https://github.com/CategoricalData/hydra/issues/80)), property graph validation ([#100](https://github.com/CategoricalData/hydra/issues/100)),+JSON bidirectional support in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)),+OpenCypher initial model ([#108](https://github.com/CategoricalData/hydra/issues/108)),+Cypher unification, and the start of the typed-DSL story in Haskell.++### New features++- Property graph validation: validator type, optionality on property types,+  customizable id/property handling in the merging adapter, fine-tuned validation,+  comprehensive unit tests in Java ([#100](https://github.com/CategoricalData/hydra/issues/100)).+- Bidirectional JSON serialization/deserialization in Java ([#104](https://github.com/CategoricalData/hydra/issues/104)).+- Checkstyle configuration based on Google style guide ([#111](https://github.com/CategoricalData/hydra/issues/111)).+- Python3 syntax model based on the official Python BNF ([#80](https://github.com/CategoricalData/hydra/issues/80)).+- Initial OpenCypher model and parser scaffold ([#108](https://github.com/CategoricalData/hydra/issues/108)).+- Protobuf coder ([#99](https://github.com/CategoricalData/hydra/issues/99)): type encoder, field numbering, formatting, deprecated annotation,+  Java options, non-string options.+- Adapter framework tolerance of recursive types ([#58](https://github.com/CategoricalData/hydra/issues/58)); default branch for case+  statements ([#60](https://github.com/CategoricalData/hydra/issues/60)).+- Topological sort in type inference ([#67](https://github.com/CategoricalData/hydra/issues/67)).+- `hydra/query` model ([#73](https://github.com/CategoricalData/hydra/issues/73)).+- Records-to-TinkerPop-elements coder ([#64](https://github.com/CategoricalData/hydra/issues/64)).+- Equality primitives for all literal types ([#92](https://github.com/CategoricalData/hydra/issues/92)); polymorphic logic primitives ([#95](https://github.com/CategoricalData/hydra/issues/95)).+- `mapKeys` primitive ([#93](https://github.com/CategoricalData/hydra/issues/93)).+- Tuple support in Java ([#94](https://github.com/CategoricalData/hydra/issues/94)).+- Java 8 as an optional target ([#96](https://github.com/CategoricalData/hydra/issues/96)); optionally generate Java classes as `Serializable` ([#97](https://github.com/CategoricalData/hydra/issues/97)).+- Bidirectional "merged vertex" and "merged edge" coders ([#106](https://github.com/CategoricalData/hydra/issues/106)).+- Nullability and parameterization in the tabular model ([#107](https://github.com/CategoricalData/hydra/issues/107)).+- Term-level / type-level dependency distinction for modules ([#109](https://github.com/CategoricalData/hydra/issues/109)).+- Flatten nested `let` terms for transformation into Java ([#110](https://github.com/CategoricalData/hydra/issues/110)).+- Various `Flow` utilities in Java: `bind3`; convenience methods for consuming results;+  `fromFlow` variants including one that throws.++### Improvements++- Hydra-Java module ports ([#10](https://github.com/CategoricalData/hydra/issues/10), [#12](https://github.com/CategoricalData/hydra/issues/12), [#13](https://github.com/CategoricalData/hydra/issues/13), [#14](https://github.com/CategoricalData/hydra/issues/14), [#17](https://github.com/CategoricalData/hydra/issues/17), [#30](https://github.com/CategoricalData/hydra/issues/30), [#31](https://github.com/CategoricalData/hydra/issues/31), [#32](https://github.com/CategoricalData/hydra/issues/32), [#33](https://github.com/CategoricalData/hydra/issues/33), [#34](https://github.com/CategoricalData/hydra/issues/34), [#35](https://github.com/CategoricalData/hydra/issues/35),+  [#38](https://github.com/CategoricalData/hydra/issues/38), [#39](https://github.com/CategoricalData/hydra/issues/39), [#41](https://github.com/CategoricalData/hydra/issues/41), [#43](https://github.com/CategoricalData/hydra/issues/43), [#48](https://github.com/CategoricalData/hydra/issues/48), [#71](https://github.com/CategoricalData/hydra/issues/71), [#72](https://github.com/CategoricalData/hydra/issues/72), [#75](https://github.com/CategoricalData/hydra/issues/75), [#83](https://github.com/CategoricalData/hydra/issues/83)):+  `Common`, `CoreEncoding`, `CoreLanguage`, `Kernel`, `Flows`, `Lists`, `Literals`,+  `Math`, `Sets`, `Strings`, `Optionals`, `Maps`, `Flows` primitives, `Sets` primitives.+- Common DSLs in Haskell: Flow support ([#68](https://github.com/CategoricalData/hydra/issues/68)), Let support ([#69](https://github.com/CategoricalData/hydra/issues/69)).+- Renamed annotation type parameter `m` to `a` ([#41](https://github.com/CategoricalData/hydra/issues/41)).+- Updated wrapper, element, and variable types ([#75](https://github.com/CategoricalData/hydra/issues/75)).+- Removed `schema` field from `Element` ([#83](https://github.com/CategoricalData/hydra/issues/83)).+- GraphQL coder ([#78](https://github.com/CategoricalData/hydra/issues/78)).+- Code quality:+  - Updated main and test sources to conform to Checkstyle configuration ([#111](https://github.com/CategoricalData/hydra/issues/111)).+  - Extended line-length limit from 100 to 120 characters.+  - Disabled overly restrictive indentation and import-order rules.+  - Disabled `RightCurlyAlone` for compact inline map definitions.+- Streamlined property-graph element merging to unify properties with identical+  keys and types ([#106](https://github.com/CategoricalData/hydra/issues/106)).+- Convenience functions for printing literals and literal types in the Java DSL.+- Minor addition to JSON decoding.+- DSL convenience: alphabetic-case flexibility for element names ([#7](https://github.com/CategoricalData/hydra/issues/7)).++### Bug fixes++- Fixed type annotations for the Sets Java port ([#48](https://github.com/CategoricalData/hydra/issues/48)).+- Various minor fixes during the Java module ports.++---++## [0.1.1] - 2022-12-04++Patch release the same day as 0.1.0.+README polish only.++---++## [0.1.0] - 2022-12-04++First packaged release of Hydra (Hackage).+This release contains the complete foundation of Hydra.++### Core language++- Hydra's core type and data languages (`hydra.core`).+- Core models for graphs and modules.+- Computation model with the `Flow` monad.+- BNF grammars support.+- Phantom types.+- Basic operations on types and terms.++### Type system++- Hindley–Milner-style type inference.+- Type schemes with polymorphism.+- Type/term validation.++### Transformations++- Adapter system: type-to-type rewriting and transformation.+- Coders:+  Haskell coder (types and terms),+  Java coder (types and terms),+  partial Scala coder (terms only),+  Avro coder,+  JSON coder,+  PDL (Pegasus Data Language) coder,+  RDF + SHACL coder,+  YAML coder.++### Language support++- Models for GraphQL, OWL (Web Ontology Language), ShEx (Shape Expressions),+  and TinkerPop-style property graphs.++### Developer tools++- Type-construction DSL and term-construction DSL.+- QuickCheck property-based tests.++### Implementations++- Hydra-Haskell: bootstrapping implementation with full kernel.+- Hydra-Java: Java implementation with mature tooling.++### Community++- Set up the LambdaGraph Discord server ([#2](https://github.com/CategoricalData/hydra/issues/2)).++---++## Contributing++We welcome contributions! Please see:++- [Developer recipes](https://github.com/CategoricalData/hydra/tree/main/docs/recipes)+- [LambdaGraph Discord](https://bit.ly/lg-discord)++## Release process++See the [Release policy](https://github.com/CategoricalData/hydra/wiki/Release-policy)+wiki page and [docs/release-workflow.md](docs/release-workflow.md)+for information on how Hydra releases are versioned, built, and published.
+ LICENSE view
@@ -0,0 +1,201 @@+                                 Apache License+                           Version 2.0, January 2004+                        http://www.apache.org/licenses/++   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION++   1. Definitions.++      "License" shall mean the terms and conditions for use, reproduction,+      and distribution as defined by Sections 1 through 9 of this document.++      "Licensor" shall mean the copyright owner or entity authorized by+      the copyright owner that is granting the License.++      "Legal Entity" shall mean the union of the acting entity and all+      other entities that control, are controlled by, or are under common+      control with that entity. For the purposes of this definition,+      "control" means (i) the power, direct or indirect, to cause the+      direction or management of such entity, whether by contract or+      otherwise, or (ii) ownership of fifty percent (50%) or more of the+      outstanding shares, or (iii) beneficial ownership of such entity.++      "You" (or "Your") shall mean an individual or Legal Entity+      exercising permissions granted by this License.++      "Source" form shall mean the preferred form for making modifications,+      including but not limited to software source code, documentation+      source, and configuration files.++      "Object" form shall mean any form resulting from mechanical+      transformation or translation of a Source form, including but+      not limited to compiled object code, generated documentation,+      and conversions to other media types.++      "Work" shall mean the work of authorship, whether in Source or+      Object form, made available under the License, as indicated by a+      copyright notice that is included in or attached to the work+      (an example is provided in the Appendix below).++      "Derivative Works" shall mean any work, whether in Source or Object+      form, that is based on (or derived from) the Work and for which the+      editorial revisions, annotations, elaborations, or other modifications+      represent, as a whole, an original work of authorship. For the purposes+      of this License, Derivative Works shall not include works that remain+      separable from, or merely link (or bind by name) to the interfaces of,+      the Work and Derivative Works thereof.++      "Contribution" shall mean any work of authorship, including+      the original version of the Work and any modifications or additions+      to that Work or Derivative Works thereof, that is intentionally+      submitted to Licensor for inclusion in the Work by the copyright owner+      or by an individual or Legal Entity authorized to submit on behalf of+      the copyright owner. For the purposes of this definition, "submitted"+      means any form of electronic, verbal, or written communication sent+      to the Licensor or its representatives, including but not limited to+      communication on electronic mailing lists, source code control systems,+      and issue tracking systems that are managed by, or on behalf of, the+      Licensor for the purpose of discussing and improving the Work, but+      excluding communication that is conspicuously marked or otherwise+      designated in writing by the copyright owner as "Not a Contribution."++      "Contributor" shall mean Licensor and any individual or Legal Entity+      on behalf of whom a Contribution has been received by Licensor and+      subsequently incorporated within the Work.++   2. Grant of Copyright License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      copyright license to reproduce, prepare Derivative Works of,+      publicly display, publicly perform, sublicense, and distribute the+      Work and such Derivative Works in Source or Object form.++   3. Grant of Patent License. Subject to the terms and conditions of+      this License, each Contributor hereby grants to You a perpetual,+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable+      (except as stated in this section) patent license to make, have made,+      use, offer to sell, sell, import, and otherwise transfer the Work,+      where such license applies only to those patent claims licensable+      by such Contributor that are necessarily infringed by their+      Contribution(s) alone or by combination of their Contribution(s)+      with the Work to which such Contribution(s) was submitted. If You+      institute patent litigation against any entity (including a+      cross-claim or counterclaim in a lawsuit) alleging that the Work+      or a Contribution incorporated within the Work constitutes direct+      or contributory patent infringement, then any patent licenses+      granted to You under this License for that Work shall terminate+      as of the date such litigation is filed.++   4. Redistribution. You may reproduce and distribute copies of the+      Work or Derivative Works thereof in any medium, with or without+      modifications, and in Source or Object form, provided that You+      meet the following conditions:++      (a) You must give any other recipients of the Work or+          Derivative Works a copy of this License; and++      (b) You must cause any modified files to carry prominent notices+          stating that You changed the files; and++      (c) You must retain, in the Source form of any Derivative Works+          that You distribute, all copyright, patent, trademark, and+          attribution notices from the Source form of the Work,+          excluding those notices that do not pertain to any part of+          the Derivative Works; and++      (d) If the Work includes a "NOTICE" text file as part of its+          distribution, then any Derivative Works that You distribute must+          include a readable copy of the attribution notices contained+          within such NOTICE file, excluding those notices that do not+          pertain to any part of the Derivative Works, in at least one+          of the following places: within a NOTICE text file distributed+          as part of the Derivative Works; within the Source form or+          documentation, if provided along with the Derivative Works; or,+          within a display generated by the Derivative Works, if and+          wherever such third-party notices normally appear. The contents+          of the NOTICE file are for informational purposes only and+          do not modify the License. You may add Your own attribution+          notices within Derivative Works that You distribute, alongside+          or as an addendum to the NOTICE text from the Work, provided+          that such additional attribution notices cannot be construed+          as modifying the License.++      You may add Your own copyright statement to Your modifications and+      may provide additional or different license terms and conditions+      for use, reproduction, or distribution of Your modifications, or+      for any such Derivative Works as a whole, provided Your use,+      reproduction, and distribution of the Work otherwise complies with+      the conditions stated in this License.++   5. Submission of Contributions. Unless You explicitly state otherwise,+      any Contribution intentionally submitted for inclusion in the Work+      by You to the Licensor shall be under the terms and conditions of+      this License, without any additional terms or conditions.+      Notwithstanding the above, nothing herein shall supersede or modify+      the terms of any separate license agreement you may have executed+      with Licensor regarding such Contributions.++   6. Trademarks. This License does not grant permission to use the trade+      names, trademarks, service marks, or product names of the Licensor,+      except as required for reasonable and customary use in describing the+      origin of the Work and reproducing the content of the NOTICE file.++   7. Disclaimer of Warranty. Unless required by applicable law or+      agreed to in writing, Licensor provides the Work (and each+      Contributor provides its Contributions) on an "AS IS" BASIS,+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or+      implied, including, without limitation, any warranties or conditions+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A+      PARTICULAR PURPOSE. You are solely responsible for determining the+      appropriateness of using or redistributing the Work and assume any+      risks associated with Your exercise of permissions under this License.++   8. Limitation of Liability. In no event and under no legal theory,+      whether in tort (including negligence), contract, or otherwise,+      unless required by applicable law (such as deliberate and grossly+      negligent acts) or agreed to in writing, shall any Contributor be+      liable to You for damages, including any direct, indirect, special,+      incidental, or consequential damages of any character arising as a+      result of this License or out of the use or inability to use the+      Work (including but not limited to damages for loss of goodwill,+      work stoppage, computer failure or malfunction, or any and all+      other commercial damages or losses), even if such Contributor+      has been advised of the possibility of such damages.++   9. Accepting Warranty or Additional Liability. While redistributing+      the Work or Derivative Works thereof, You may choose to offer,+      and charge a fee for, acceptance of support, warranty, indemnity,+      or other liability obligations and/or rights consistent with this+      License. However, in accepting such obligations, You may act only+      on Your own behalf and on Your sole responsibility, not on behalf+      of any other Contributor, and only if You agree to indemnify,+      defend, and hold each Contributor harmless for any liability+      incurred by, or claims asserted against, such Contributor by reason+      of your accepting any such warranty or additional liability.++   END OF TERMS AND CONDITIONS++   APPENDIX: How to apply the Apache License to your work.++      To apply the Apache License to your work, attach the following+      boilerplate notice, with the fields enclosed by brackets "[]"+      replaced with your own identifying information. (Don't include+      the brackets!)  The text should be enclosed in the appropriate+      comment syntax for the file format. We also recommend that a+      file or class name and description of purpose be included on the+      same "printed page" as the copyright notice for easier+      identification within third-party archives.++   Copyright [yyyy] [name of copyright owner]++   Licensed under the Apache License, Version 2.0 (the "License");+   you may not use this file except in compliance with the License.+   You may obtain a copy of the License at++       http://www.apache.org/licenses/LICENSE-2.0++   Unless required by applicable law or agreed to in writing, software+   distributed under the License is distributed on an "AS IS" BASIS,+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+   See the License for the specific language governing permissions and+   limitations under the License.
+ hydra-kernel.cabal view
@@ -0,0 +1,257 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.38.1.+--+-- see: https://github.com/sol/hpack++name:           hydra-kernel+version:        0.16.0+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+homepage:       https://github.com/CategoricalData/hydra#readme+bug-reports:    https://github.com/CategoricalData/hydra/issues+author:         Joshua Shinavier <josh@fortytwo.net>+maintainer:     Joshua Shinavier <josh@fortytwo.net>+license:        Apache-2.0+license-file:   LICENSE+build-type:     Simple+extra-source-files:+    LICENSE+    CHANGELOG.md++source-repository head+  type: git+  location: https://github.com/CategoricalData/hydra++library+  exposed-modules:+      Hydra.Adapt+      Hydra.Analysis+      Hydra.Annotations+      Hydra.Arity+      Hydra.Ast+      Hydra.Checking+      Hydra.Classes+      Hydra.Codegen+      Hydra.Coders+      Hydra.Constants+      Hydra.Core+      Hydra.Decode.Ast+      Hydra.Decode.Coders+      Hydra.Decode.Core+      Hydra.Decode.Error.Checking+      Hydra.Decode.Error.Core+      Hydra.Decode.Errors+      Hydra.Decode.Json.Model+      Hydra.Decode.Packaging+      Hydra.Decode.Parsing+      Hydra.Decode.Paths+      Hydra.Decode.Query+      Hydra.Decode.Relational+      Hydra.Decode.Tabular+      Hydra.Decode.Testing+      Hydra.Decode.Topology+      Hydra.Decode.Typed+      Hydra.Decode.Typing+      Hydra.Decode.Util+      Hydra.Decode.Variants+      Hydra.Decoding+      Hydra.Dependencies+      Hydra.Differentiation+      Hydra.Dsl.Ast+      Hydra.Dsl.Coders+      Hydra.Dsl.Core+      Hydra.Dsl.Error.Checking+      Hydra.Dsl.Error.Core+      Hydra.Dsl.Error.Packaging+      Hydra.Dsl.Errors+      Hydra.Dsl.Graph+      Hydra.Dsl.Json.Model+      Hydra.Dsl.Literals+      Hydra.Dsl.Meta.Common+      Hydra.Dsl.Packaging+      Hydra.Dsl.Parsing+      Hydra.Dsl.Paths+      Hydra.Dsl.Query+      Hydra.Dsl.Relational+      Hydra.Dsl.Tabular+      Hydra.Dsl.Terms+      Hydra.Dsl.Testing+      Hydra.Dsl.Topology+      Hydra.Dsl.Typing+      Hydra.Dsl.Util+      Hydra.Dsl.Validation+      Hydra.Dsl.Variants+      Hydra.Dsl.Yaml.Model+      Hydra.Dsls+      Hydra.Encode.Ast+      Hydra.Encode.Coders+      Hydra.Encode.Core+      Hydra.Encode.Error.Checking+      Hydra.Encode.Error.Core+      Hydra.Encode.Errors+      Hydra.Encode.Json.Model+      Hydra.Encode.Packaging+      Hydra.Encode.Parsing+      Hydra.Encode.Paths+      Hydra.Encode.Query+      Hydra.Encode.Relational+      Hydra.Encode.Tabular+      Hydra.Encode.Testing+      Hydra.Encode.Topology+      Hydra.Encode.Typed+      Hydra.Encode.Typing+      Hydra.Encode.Util+      Hydra.Encode.Variants+      Hydra.Encoding+      Hydra.Environment+      Hydra.Error.Checking+      Hydra.Error.Core+      Hydra.Error.Packaging+      Hydra.Errors+      Hydra.Extract.Core+      Hydra.Extract.Json+      Hydra.Extract.Util+      Hydra.Formatting+      Hydra.Graph+      Hydra.Haskell.Lib.Chars+      Hydra.Haskell.Lib.Eithers+      Hydra.Haskell.Lib.Equality+      Hydra.Haskell.Lib.Lists+      Hydra.Haskell.Lib.Literals+      Hydra.Haskell.Lib.Logic+      Hydra.Haskell.Lib.Maps+      Hydra.Haskell.Lib.Math+      Hydra.Haskell.Lib.Optionals+      Hydra.Haskell.Lib.Pairs+      Hydra.Haskell.Lib.Regex+      Hydra.Haskell.Lib.Sets+      Hydra.Haskell.Lib.Strings+      Hydra.Hoisting+      Hydra.Inference+      Hydra.Json.Bootstrap+      Hydra.Json.Decode+      Hydra.Json.Decoding+      Hydra.Json.Encode+      Hydra.Json.Model+      Hydra.Json.Parser+      Hydra.Json.Writer+      Hydra.Json.Yaml.Decode+      Hydra.Json.Yaml.Encode+      Hydra.Kernel+      Hydra.Languages+      Hydra.Lexical+      Hydra.Lib.Chars+      Hydra.Lib.Eithers+      Hydra.Lib.Equality+      Hydra.Lib.Lists+      Hydra.Lib.Literals+      Hydra.Lib.Logic+      Hydra.Lib.Maps+      Hydra.Lib.Math+      Hydra.Lib.Optionals+      Hydra.Lib.Pairs+      Hydra.Lib.Regex+      Hydra.Lib.Sets+      Hydra.Lib.Strings+      Hydra.Literals+      Hydra.Names+      Hydra.Packaging+      Hydra.Parsers+      Hydra.Parsing+      Hydra.Paths+      Hydra.Predicates+      Hydra.Query+      Hydra.Reduction+      Hydra.Reflect+      Hydra.Relational+      Hydra.Resolution+      Hydra.Rewriting+      Hydra.Scoping+      Hydra.Serialization+      Hydra.Settings+      Hydra.Show.Core+      Hydra.Show.Error.Core+      Hydra.Show.Error.Packaging+      Hydra.Show.Errors+      Hydra.Show.Graph+      Hydra.Show.Paths+      Hydra.Show.Typing+      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+      Hydra.Templates+      Hydra.Test.Transform+      Hydra.Test.Utils+      Hydra.Testing+      Hydra.Topology+      Hydra.Typed+      Hydra.Typing+      Hydra.Unification+      Hydra.Util+      Hydra.Validate.Core+      Hydra.Validate.Packaging+      Hydra.Validation+      Hydra.Variables+      Hydra.Variants+      Hydra.Yaml.Model+  other-modules:+      Paths_hydra_kernel+  hs-source-dirs:+      src/main/haskell+  build-depends:+      base >=4.19.0 && <4.22+    , base64-bytestring >=1.2.1 && <1.3+    , bytestring >=0.11.5 && <0.13+    , containers >=0.6.7 && <0.8+    , regex-tdfa >=1.3.2 && <1.4+    , scientific >=0.3.7 && <0.4+    , split >=0.2.3 && <0.3+    , text >=2.0.2 && <2.2+  default-language: Haskell2010
+ src/main/haskell/Hydra/Adapt.hs view
@@ -0,0 +1,780 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Simple, one-way adapters for types and terms++module Hydra.Adapt where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Environment as Environment+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Hoisting as Hoisting+import qualified Hydra.Inference as Inference+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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 LibLiterals+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Literals as Literals+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Reduction as Reduction+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Resolution as Resolution+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Show.Graph as ShowGraph+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Adapt a graph and its schema to the given language constraints. The doExpand flag controls eta expansion of partial applications. Adaptation is type-preserving: binding-level TypeSchemes are adapted (not stripped). Note: case statement hoisting is done separately, prior to adaptation. The els0 parameter provides the original ordered bindings. Returns both the adapted graph and the ordered adapted bindings.+adaptDataGraph :: Coders.LanguageConstraints -> Bool -> [Core.Binding] -> t0 -> Graph.Graph -> Either Errors.Error (Graph.Graph, [Core.Binding])+adaptDataGraph constraints doExpand els0 cx graph0 =++      let transformTerm =+              \g -> \term ->+                let tx = g+                    t1 = Variables.unshadowVariables (pushTypeAppsInward term)+                    t2 = Variables.unshadowVariables (Logic.ifElse doExpand (pushTypeAppsInward (Reduction.etaExpandTerm tx t1)) t1)+                in (Dependencies.liftLambdaAboveLet t2)+          transformBinding =+                  \g -> \el -> Core.Binding {+                    Core.bindingName = (Core.bindingName el),+                    Core.bindingTerm = (transformTerm g (Core.bindingTerm el)),+                    Core.bindingTypeScheme = (Core.bindingTypeScheme el)}+          litmap = adaptLiteralTypesMap constraints+          prims0 = Graph.graphPrimitives graph0+          schemaTypes0 = Graph.graphSchemaTypes graph0+          schemaBindings = Environment.typesToDefinitions (Maps.map (\ts -> Scoping.typeSchemeToFType ts) schemaTypes0)+      in (Eithers.bind (Logic.ifElse (Maps.null schemaTypes0) (Right Maps.empty) (Eithers.bind (Eithers.bimap (\e -> Errors.ErrorDecoding e) (\x -> x) (Environment.graphAsTypes graph0 schemaBindings)) (\tmap0 -> Eithers.bind (adaptGraphSchema constraints litmap tmap0) (\tmap1 -> Right (Maps.map (\t -> Resolution.typeToTypeScheme t) tmap1))))) (\schemaResult ->+        let adaptedSchemaTypes = schemaResult+            adaptBinding =+                    \el ->+                      let transformed = transformBinding graph0 el+                          wrapped =+                                  Core.TermLet (Core.Let {+                                    Core.letBindings = (Lists.pure transformed),+                                    Core.letBody = Core.TermUnit})+                      in (Eithers.bind (adaptTerm constraints litmap cx graph0 wrapped) (\adapted -> Rewriting.rewriteTermM (adaptLambdaDomains constraints litmap) adapted))+        in (Eithers.bind (Eithers.mapList adaptBinding els0) (\adaptedTerms ->+          let els1Raw = Lists.concat (Lists.map Environment.termAsBindings adaptedTerms)+              processBinding =+                      \el -> Eithers.bind (Rewriting.rewriteTermM (adaptNestedTypes constraints litmap) (Core.bindingTerm el)) (\newTerm -> Eithers.bind (Optionals.cases (Core.bindingTypeScheme el) (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1)))) (\adaptedType -> Right (Core.Binding {+                        Core.bindingName = (Core.bindingName el),+                        Core.bindingTerm = newTerm,+                        Core.bindingTypeScheme = adaptedType})))+          in (Eithers.bind (Eithers.mapList processBinding els1Raw) (\els1 -> Eithers.bind (Eithers.mapList (\kv -> Eithers.bind (adaptPrimitive constraints litmap (Pairs.second kv)) (\prim1 -> Right (Pairs.first kv, prim1))) (Maps.toList prims0)) (\primPairs ->+            let prims1 = Maps.fromList primPairs+                adaptedGraphRaw = Lexical.buildGraph els1 Maps.empty prims1+                adaptedGraph =+                        Graph.Graph {+                          Graph.graphBoundTerms = (Graph.graphBoundTerms adaptedGraphRaw),+                          Graph.graphBoundTypes = (Graph.graphBoundTypes adaptedGraphRaw),+                          Graph.graphClassConstraints = (Graph.graphClassConstraints adaptedGraphRaw),+                          Graph.graphLambdaVariables = (Graph.graphLambdaVariables adaptedGraphRaw),+                          Graph.graphMetadata = (Graph.graphMetadata adaptedGraphRaw),+                          Graph.graphPrimitives = (Graph.graphPrimitives adaptedGraphRaw),+                          Graph.graphSchemaTypes = adaptedSchemaTypes,+                          Graph.graphTypeVariables = (Graph.graphTypeVariables adaptedGraphRaw)}+            in (Right (adaptedGraph, els1)))))))))+-- | Attempt to adapt a floating-point type using the given language constraints+adaptFloatType :: Coders.LanguageConstraints -> Core.FloatType -> Maybe Core.FloatType+adaptFloatType constraints ft =++      let supported = Sets.member ft (Coders.languageConstraintsFloatTypes constraints)+          alt = adaptFloatType constraints+          forUnsupported =+                  \ft2 -> case ft2 of+                    Core.FloatTypeFloat32 -> alt Core.FloatTypeFloat64+                    Core.FloatTypeFloat64 -> alt Core.FloatTypeFloat32+      in (Logic.ifElse supported (Just ft) (forUnsupported ft))+-- | Adapt a schema graph to the given language constraints+adaptGraphSchema :: Ord t0 => (Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> M.Map t0 Core.Type -> Either Errors.Error (M.Map t0 Core.Type))+adaptGraphSchema constraints litmap types0 =++      let mapPair =+              \pair ->+                let name = Pairs.first pair+                    typ = Pairs.second pair+                in (Eithers.bind (adaptType constraints litmap typ) (\typ1 -> Right (name, typ1)))+      in (Eithers.bind (Eithers.mapList mapPair (Maps.toList types0)) (\pairs -> Right (Maps.fromList pairs)))+-- | Attempt to adapt an integer type using the given language constraints+adaptIntegerType :: Coders.LanguageConstraints -> Core.IntegerType -> Maybe Core.IntegerType+adaptIntegerType constraints it =++      let supported = Sets.member it (Coders.languageConstraintsIntegerTypes constraints)+          alt = adaptIntegerType constraints+          forUnsupported =+                  \it2 -> case it2 of+                    Core.IntegerTypeBigint -> Nothing+                    Core.IntegerTypeInt8 -> alt Core.IntegerTypeUint16+                    Core.IntegerTypeInt16 -> alt Core.IntegerTypeUint32+                    Core.IntegerTypeInt32 -> alt Core.IntegerTypeUint64+                    Core.IntegerTypeInt64 -> alt Core.IntegerTypeBigint+                    Core.IntegerTypeUint8 -> alt Core.IntegerTypeInt16+                    Core.IntegerTypeUint16 -> alt Core.IntegerTypeInt32+                    Core.IntegerTypeUint32 -> alt Core.IntegerTypeInt64+                    Core.IntegerTypeUint64 -> alt Core.IntegerTypeBigint+      in (Logic.ifElse supported (Just it) (forUnsupported it))+-- | Rewrite callback for adapting lambda domain types in a term+adaptLambdaDomains :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> (t0 -> Either Errors.Error Core.Term) -> t0 -> Either Errors.Error Core.Term+adaptLambdaDomains constraints litmap recurse term =+    Eithers.bind (recurse term) (\rewritten -> case rewritten of+      Core.TermLambda v0 -> Eithers.bind (Optionals.cases (Core.lambdaDomain v0) (Right Nothing) (\dom -> Eithers.bind (adaptType constraints litmap dom) (\dom1 -> Right (Just dom1)))) (\adaptedDomain -> Right (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.lambdaParameter v0),+        Core.lambdaDomain = adaptedDomain,+        Core.lambdaBody = (Core.lambdaBody v0)})))+      _ -> Right rewritten)+-- | Convert a literal to a different type+adaptLiteral :: Core.LiteralType -> Core.Literal -> Core.Literal+adaptLiteral lt l =+    case l of+      Core.LiteralBinary v0 -> case lt of+        Core.LiteralTypeString -> Core.LiteralString (LibLiterals.binaryToString v0)+      Core.LiteralBoolean v0 -> case lt of+        Core.LiteralTypeInteger v1 -> Core.LiteralInteger (Literals.bigintToIntegerValue v1 (Logic.ifElse v0 1 0))+      Core.LiteralDecimal v0 -> case lt of+        Core.LiteralTypeFloat _ -> Core.LiteralFloat (Core.FloatValueFloat64 (LibLiterals.decimalToFloat64 v0))+        Core.LiteralTypeString -> Core.LiteralString (LibLiterals.showDecimal v0)+      Core.LiteralFloat v0 -> case lt of+        Core.LiteralTypeFloat v1 -> Core.LiteralFloat (case v1 of+          Core.FloatTypeFloat32 -> Core.FloatValueFloat32 (case v0 of+            Core.FloatValueFloat32 v3 -> v3+            Core.FloatValueFloat64 v3 -> LibLiterals.float64ToFloat32 v3)+          Core.FloatTypeFloat64 -> Core.FloatValueFloat64 (case v0 of+            Core.FloatValueFloat32 v3 -> LibLiterals.float32ToFloat64 v3+            Core.FloatValueFloat64 v3 -> v3))+      Core.LiteralInteger v0 -> case lt of+        Core.LiteralTypeInteger v1 -> Core.LiteralInteger (Literals.bigintToIntegerValue v1 (Literals.integerValueToBigint v0))+-- | Attempt to adapt a literal type using the given language constraints+adaptLiteralType :: Coders.LanguageConstraints -> Core.LiteralType -> Maybe Core.LiteralType+adaptLiteralType constraints lt =++      let forUnsupported =+              \lt2 -> case lt2 of+                Core.LiteralTypeBinary -> Just Core.LiteralTypeString+                Core.LiteralTypeBoolean -> Optionals.map (\x -> Core.LiteralTypeInteger x) (adaptIntegerType constraints Core.IntegerTypeInt8)+                Core.LiteralTypeDecimal -> Just (Core.LiteralTypeFloat Core.FloatTypeFloat64)+                Core.LiteralTypeFloat v0 -> Optionals.map (\x -> Core.LiteralTypeFloat x) (adaptFloatType constraints v0)+                Core.LiteralTypeInteger v0 -> Optionals.map (\x -> Core.LiteralTypeInteger x) (adaptIntegerType constraints v0)+                _ -> Nothing+      in (Logic.ifElse (literalTypeSupported constraints lt) Nothing (forUnsupported lt))+-- | Derive a map of adapted literal types for the given language constraints+adaptLiteralTypesMap :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType+adaptLiteralTypesMap constraints =++      let tryType = \lt -> Optionals.cases (adaptLiteralType constraints lt) Nothing (\lt2 -> Just (lt, lt2))+      in (Maps.fromList (Optionals.cat (Lists.map tryType Reflect.literalTypes)))+-- | Adapt a literal value using the given language constraints+adaptLiteralValue :: Ord t0 => (M.Map t0 Core.LiteralType -> t0 -> Core.Literal -> Core.Literal)+adaptLiteralValue litmap lt l =+    Optionals.cases (Maps.lookup lt litmap) (Core.LiteralString (ShowCore.literal l)) (\lt2 -> adaptLiteral lt2 l)+-- | Rewrite callback for adapting nested let binding TypeSchemes in a term+adaptNestedTypes :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> (t0 -> Either Errors.Error Core.Term) -> t0 -> Either Errors.Error Core.Term+adaptNestedTypes constraints litmap recurse term =+    Eithers.bind (recurse term) (\rewritten -> case rewritten of+      Core.TermLet v0 ->+        let adaptB =+                \b -> Eithers.bind (Optionals.cases (Core.bindingTypeScheme b) (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1)))) (\adaptedBType -> Right (Core.Binding {+                  Core.bindingName = (Core.bindingName b),+                  Core.bindingTerm = (Core.bindingTerm b),+                  Core.bindingTypeScheme = adaptedBType}))+        in (Eithers.bind (Eithers.mapList adaptB (Core.letBindings v0)) (\adaptedBindings -> Right (Core.TermLet (Core.Let {+          Core.letBindings = adaptedBindings,+          Core.letBody = (Core.letBody v0)}))))+      _ -> Right rewritten)+-- | Adapt a primitive to the given language constraints, prior to inference+adaptPrimitive :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Graph.Primitive -> Either Errors.Error Graph.Primitive+adaptPrimitive constraints litmap prim0 =++      let def0 = Graph.primitiveDefinition prim0+      in (Eithers.bind (adaptTermSignature constraints litmap (Packaging.primitiveDefinitionSignature def0)) (\sig1 ->+        let def1 =+                Packaging.PrimitiveDefinition {+                  Packaging.primitiveDefinitionName = (Packaging.primitiveDefinitionName def0),+                  Packaging.primitiveDefinitionMetadata = (Packaging.primitiveDefinitionMetadata def0),+                  Packaging.primitiveDefinitionSignature = sig1,+                  Packaging.primitiveDefinitionIsPure = (Packaging.primitiveDefinitionIsPure def0),+                  Packaging.primitiveDefinitionIsTotal = (Packaging.primitiveDefinitionIsTotal def0),+                  Packaging.primitiveDefinitionDefaultImplementation = (Packaging.primitiveDefinitionDefaultImplementation def0)}+        in (Right (Graph.Primitive {+          Graph.primitiveDefinition = def1,+          Graph.primitiveImplementation = (Graph.primitiveImplementation prim0)}))))+-- | Adapt a term using the given language constraints+adaptTerm :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> t0 -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+adaptTerm constraints litmap cx graph term0 =++      let rewrite =+              \recurse -> \term02 ->+                let forSupported =+                        \term -> case term of+                          Core.TermLiteral v0 ->+                            let lt = Reflect.literalType v0+                            in (Right (Just (Logic.ifElse (literalTypeSupported constraints lt) term (Core.TermLiteral (adaptLiteralValue litmap lt v0)))))+                          _ -> Right (Just term)+                    forUnsupported =+                            \term ->+                              let tryAlts =+                                      \alts -> Optionals.cases (Lists.uncons alts) (Right Nothing) (\uc -> Eithers.bind (tryTerm (Pairs.first uc)) (\mterm -> Optionals.cases mterm (tryAlts (Pairs.second uc)) (\t -> Right (Just t))))+                              in (Eithers.bind (termAlternatives cx graph term) (\alts0 -> tryAlts alts0))+                    tryTerm =+                            \term ->+                              let supportedVariant = Sets.member (Reflect.termVariant term) (Coders.languageConstraintsTermVariants constraints)+                              in (Logic.ifElse supportedVariant (forSupported term) (forUnsupported term))+                in (Eithers.bind (recurse term02) (\term1 -> case term1 of+                  Core.TermAnnotated _ -> Right term1+                  Core.TermTypeApplication v0 -> Eithers.bind (adaptType constraints litmap (Core.typeApplicationTermType v0)) (\atyp -> Right (Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = (Core.typeApplicationTermBody v0),+                    Core.typeApplicationTermType = atyp})))+                  Core.TermTypeLambda _ -> Right term1+                  _ -> Eithers.bind (tryTerm term1) (\mterm -> Optionals.cases mterm (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no alternatives for term: " (ShowCore.term term1))))) (\term2 -> Right term2))))+      in (Rewriting.rewriteTermM rewrite term0)+-- | Adapt a term using the constraints of a given language+adaptTermForLanguage :: Coders.Language -> t0 -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+adaptTermForLanguage lang cx g term =++      let constraints = Coders.languageConstraints lang+          litmap = adaptLiteralTypesMap constraints+      in (adaptTerm constraints litmap cx g term)+-- | Adapt the types within a term signature to the given language constraints, in place. Parameter names, descriptions, and per-parameter isLazy flags, as well as type parameters, are preserved; only the parameter and result types are adapted. Unlike routing through TypeScheme (the type-only view), this retains the full TermSignature metadata, including primitive laziness flags.+adaptTermSignature :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Typing.TermSignature -> Either Errors.Error Typing.TermSignature+adaptTermSignature constraints litmap sig0 =++      let result0 = Typing.termSignatureResult sig0+      in (Eithers.bind (adaptType constraints litmap (Typing.resultType result0)) (\resultType1 -> Eithers.bind (Eithers.mapList (\p -> Eithers.map (\ty1 -> Typing.Parameter {+        Typing.parameterName = (Typing.parameterName p),+        Typing.parameterDescription = (Typing.parameterDescription p),+        Typing.parameterType = ty1,+        Typing.parameterIsLazy = (Typing.parameterIsLazy p)}) (adaptType constraints litmap (Typing.parameterType p))) (Typing.termSignatureParameters sig0)) (\params1 -> Right (Typing.TermSignature {+        Typing.termSignatureTypeParameters = (Typing.termSignatureTypeParameters sig0),+        Typing.termSignatureParameters = params1,+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = (Typing.resultDescription result0),+          Typing.resultType = resultType1}}))))+-- | Adapt a type using the given language constraints+adaptType :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Core.Type -> Either Errors.Error Core.Type+adaptType constraints litmap type0 =++      let forSupported =+              \typ -> case typ of+                Core.TypeLiteral v0 -> Logic.ifElse (literalTypeSupported constraints v0) (Just typ) (Optionals.cases (Maps.lookup v0 litmap) (Just (Core.TypeLiteral Core.LiteralTypeString)) (\lt2 -> Just (Core.TypeLiteral lt2)))+                _ -> Just typ+          forUnsupported =+                  \typ ->+                    let tryAlts =+                            \alts -> Optionals.bind (Lists.uncons alts) (\uc -> Optionals.cases (tryType (Pairs.first uc)) (tryAlts (Pairs.second uc)) (\t -> Just t))+                        alts0 = typeAlternatives typ+                    in (tryAlts alts0)+          tryType =+                  \typ ->+                    let supportedVariant = Sets.member (Reflect.typeVariant typ) (Coders.languageConstraintsTypeVariants constraints)+                    in (Logic.ifElse supportedVariant (forSupported typ) (forUnsupported typ))+          rewrite =+                  \recurse -> \typ -> Eithers.bind (recurse typ) (\type1 -> Optionals.cases (tryType type1) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "no alternatives for type: " (ShowCore.type_ typ))))) (\type2 -> Right type2))+      in (Rewriting.rewriteTypeM rewrite type0)+-- | Adapt a type using the constraints of a given language+adaptTypeForLanguage :: Coders.Language -> Core.Type -> Either Errors.Error Core.Type+adaptTypeForLanguage lang typ =++      let constraints = Coders.languageConstraints lang+          litmap = adaptLiteralTypesMap constraints+      in (adaptType constraints litmap typ)+-- | Adapt a type scheme to the given language constraints, prior to inference+adaptTypeScheme :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> Core.TypeScheme -> Either Errors.Error Core.TypeScheme+adaptTypeScheme constraints litmap ts0 =++      let vars0 = Core.typeSchemeVariables ts0+          t0 = Core.typeSchemeBody ts0+      in (Eithers.bind (adaptType constraints litmap t0) (\t1 -> Right (Core.TypeScheme {+        Core.typeSchemeVariables = vars0,+        Core.typeSchemeBody = t1,+        Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts0)})))+-- | Compose two coders into a single coder+composeCoders :: Coders.Coder t0 t1 -> Coders.Coder t1 t2 -> Coders.Coder t0 t2+composeCoders c1 c2 =+    Coders.Coder {+      Coders.coderEncode = (\cx -> \a -> Eithers.bind (Coders.coderEncode c1 cx a) (\b1 -> Coders.coderEncode c2 cx b1)),+      Coders.coderDecode = (\cx -> \c -> Eithers.bind (Coders.coderDecode c2 cx c) (\b2 -> Coders.coderDecode c1 cx b2))}+-- | Given a data graph along with language constraints, original ordered bindings, and a designated list of namespaces, adapt the graph to the language constraints, then return the processed graph along with term definitions grouped by namespace (in the order of the input namespaces). Inference is performed before adaptation if bindings lack type annotations. Hoisting must preserve type schemes; if any binding loses its type scheme after hoisting, the pipeline fails. Adaptation preserves type application/lambda wrappers and adapts embedded types. Post-adaptation inference is performed to ensure binding TypeSchemes are fully consistent. The doExpand flag controls eta expansion. The doHoistCaseStatements flag controls case statement hoisting (needed for Python). The doHoistPolymorphicLetBindings flag controls polymorphic let binding hoisting (needed for Java). The originalBindings parameter provides the original ordered bindings (from module elements).+dataGraphToDefinitions :: Coders.LanguageConstraints -> Bool -> Bool -> Bool -> Bool -> [Core.Binding] -> Graph.Graph -> [Packaging.ModuleName] -> Typing.InferenceContext -> Either Errors.Error (Graph.Graph, [[Packaging.TermDefinition]])+dataGraphToDefinitions constraints doInfer doExpand doHoistCaseStatements doHoistPolymorphicLetBindings originalBindings graph0 namespaces cx =++      let namespacesSet = Sets.fromList namespaces+          isParentBinding =+                  \b -> Optionals.cases (Names.moduleNameOf (Core.bindingName b)) False (\ns -> Sets.member ns namespacesSet)+          hoistCases =+                  \bindings ->+                    let stripped =+                            Lists.map (\b -> Core.Binding {+                              Core.bindingName = (Core.bindingName b),+                              Core.bindingTerm = (Strip.stripTypeLambdas (Core.bindingTerm b)),+                              Core.bindingTypeScheme = (Core.bindingTypeScheme b)}) bindings+                        term0 =+                                Core.TermLet (Core.Let {+                                  Core.letBindings = stripped,+                                  Core.letBody = Core.TermUnit})+                        unshadowed0 = Environment.termAsBindings (Variables.unshadowVariables term0)+                        hoisted = Hoisting.hoistCaseStatementsInGraph unshadowed0+                        term1 =+                                Core.TermLet (Core.Let {+                                  Core.letBindings = hoisted,+                                  Core.letBody = Core.TermUnit})+                    in (Environment.termAsBindings (Variables.unshadowVariables term1))+          hoistPoly =+                  \bindings ->+                    let letBefore =+                            Core.Let {+                              Core.letBindings = bindings,+                              Core.letBody = Core.TermUnit}+                        letAfter = Hoisting.hoistPolymorphicLetBindings isParentBinding letBefore+                    in (Core.letBindings letAfter)+          qualifyUntyped =+                  \b ->+                    let nm = Core.unName (Core.bindingName b)+                    in (Optionals.cases (Names.moduleNameOf (Core.bindingName b)) (Strings.cat2 "(no module) " nm) (\ns -> Strings.cat [+                      Packaging.unModuleName ns,+                      " :: ",+                      nm]))+          checkBindingsTyped =+                  \debugLabel -> \bindings ->+                    let untypedBindings =+                            Lists.map qualifyUntyped (Lists.filter (\b -> Logic.not (Optionals.isGiven (Core.bindingTypeScheme b))) bindings)+                    in (Logic.ifElse (Lists.null untypedBindings) (Right bindings) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat [+                      "Found ",+                      (LibLiterals.showInt32 (Lists.length untypedBindings)),+                      " untyped binding(s) (",+                      debugLabel,+                      "); each must carry a type scheme at this stage. ",+                      "This usually means stale dist/json field shapes after a kernel record rename ",+                      "(regenerate the affected package's JSON). Offending bindings (module :: name): ",+                      (Strings.intercalate ", " untypedBindings)])))))+          normalizeBindings =+                  \bindings -> Lists.map (\b -> Core.Binding {+                    Core.bindingName = (Core.bindingName b),+                    Core.bindingTerm = (pushTypeAppsInward (Core.bindingTerm b)),+                    Core.bindingTypeScheme = (Core.bindingTypeScheme b)}) bindings+          rebuildGraph =+                  \bindings ->+                    let g = Lexical.buildGraph bindings Maps.empty (Graph.graphPrimitives graph0)+                    in Graph.Graph {+                      Graph.graphBoundTerms = (Graph.graphBoundTerms g),+                      Graph.graphBoundTypes = (Graph.graphBoundTypes g),+                      Graph.graphClassConstraints = (Graph.graphClassConstraints g),+                      Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),+                      Graph.graphMetadata = (Graph.graphMetadata g),+                      Graph.graphPrimitives = (Graph.graphPrimitives g),+                      Graph.graphSchemaTypes = (Graph.graphSchemaTypes graph0),+                      Graph.graphTypeVariables = (Graph.graphTypeVariables g)}+          bins0 = originalBindings+          bins1 = Logic.ifElse doHoistCaseStatements (hoistCases bins0) bins0+      in (Eithers.bind (Logic.ifElse doInfer (Eithers.map (\result -> Pairs.second (Pairs.first result)) (Inference.inferGraphTypes cx bins1 (rebuildGraph bins1))) (checkBindingsTyped "after case hoisting" bins1)) (\bins2 -> Eithers.bind (Logic.ifElse doHoistPolymorphicLetBindings (checkBindingsTyped "after let hoisting" (hoistPoly bins2)) (Right bins2)) (\bins3 -> Eithers.bind (adaptDataGraph constraints doExpand bins3 cx (rebuildGraph bins3)) (\adaptResult ->+        let adapted = Pairs.first adaptResult+            adaptedBindings = Pairs.second adaptResult+        in (Eithers.bind (checkBindingsTyped "after adaptation" adaptedBindings) (\bins4 ->+          let bins5Raw = normalizeBindings bins4+              peelOne =+                      \t -> case t of+                        Core.TermTypeLambda v0 -> Core.typeLambdaBody v0+                        Core.TermTypeApplication v0 -> Core.typeApplicationTermBody v0+                        _ -> t+              extractAnn =+                      \t -> case t of+                        Core.TermAnnotated v0 -> Just (Core.annotatedTermAnnotation v0)+                        _ -> Nothing+              findAnn =+                      \t ->+                        let t1 = peelOne t+                            t2 = peelOne t1+                            t3 = peelOne t2+                        in (Optionals.cases (extractAnn t) (Optionals.cases (extractAnn t1) (Optionals.cases (extractAnn t2) (extractAnn t3) (\a -> Just a)) (\a -> Just a)) (\a -> Just a))+              originalAnnotations =+                      Maps.fromList (Optionals.cat (Lists.map (\b -> Optionals.cases (findAnn (Core.bindingTerm b)) Nothing (\ann -> Just (Core.bindingName b, ann))) originalBindings))+              reattachAnnotation =+                      \b -> Optionals.cases (Maps.lookup (Core.bindingName b) originalAnnotations) b (\ann -> Core.Binding {+                        Core.bindingName = (Core.bindingName b),+                        Core.bindingTerm = case (Core.bindingTerm b) of+                          Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {+                            Core.annotatedTermBody = (Core.annotatedTermBody v0),+                            Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.union (Annotations.getAnnotationMap (Core.annotatedTermAnnotation v0)) (Annotations.getAnnotationMap ann)))})+                          _ -> Core.TermAnnotated (Core.AnnotatedTerm {+                            Core.annotatedTermBody = (Core.bindingTerm b),+                            Core.annotatedTermAnnotation = ann}),+                        Core.bindingTypeScheme = (Core.bindingTypeScheme b)})+              bins5 = Lists.map reattachAnnotation bins5Raw+              toDef =+                      \el -> Optionals.map (\ts -> Packaging.TermDefinition {+                        Packaging.termDefinitionName = (Core.bindingName el),+                        Packaging.termDefinitionMetadata = Nothing,+                        Packaging.termDefinitionSignature = (Just (Scoping.typeSchemeToTermSignature ts)),+                        Packaging.termDefinitionBody = (Core.bindingTerm el)}) (Core.bindingTypeScheme el)+              selectedElements =+                      Lists.filter (\el -> Optionals.cases (Names.moduleNameOf (Core.bindingName el)) False (\ns -> Sets.member ns namespacesSet)) bins5+              elementsByNamespace =+                      Lists.foldl (\acc -> \el -> Optionals.cases (Names.moduleNameOf (Core.bindingName el)) acc (\ns ->+                        let existing = Optionals.cases (Maps.lookup ns acc) [] Equality.identity+                        in (Maps.insert ns (Lists.concat2 existing [+                          el]) acc))) Maps.empty selectedElements+              defsGrouped =+                      Lists.map (\ns ->+                        let elsForNs = Optionals.cases (Maps.lookup ns elementsByNamespace) [] Equality.identity+                        in (Optionals.cat (Lists.map toDef elsForNs))) namespaces+              g = Lexical.buildGraph bins5 Maps.empty (Graph.graphPrimitives adapted)+          in (Right (+            Graph.Graph {+              Graph.graphBoundTerms = (Graph.graphBoundTerms g),+              Graph.graphBoundTypes = (Graph.graphBoundTypes g),+              Graph.graphClassConstraints = (Graph.graphClassConstraints g),+              Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),+              Graph.graphMetadata = (Graph.graphMetadata g),+              Graph.graphPrimitives = (Graph.graphPrimitives g),+              Graph.graphSchemaTypes = (Graph.graphSchemaTypes adapted),+              Graph.graphTypeVariables = (Graph.graphTypeVariables g)},+            defsGrouped))))))))+-- | Check if a literal type is supported by the given language constraints+literalTypeSupported :: Coders.LanguageConstraints -> Core.LiteralType -> Bool+literalTypeSupported constraints lt =++      let forType =+              \lt2 -> case lt2 of+                Core.LiteralTypeFloat v0 -> Sets.member v0 (Coders.languageConstraintsFloatTypes constraints)+                Core.LiteralTypeInteger v0 -> Sets.member v0 (Coders.languageConstraintsIntegerTypes constraints)+                _ -> True+      in (Logic.ifElse (Sets.member (Reflect.literalTypeVariant lt) (Coders.languageConstraintsLiteralVariants constraints)) (forType lt) False)+-- | Prepare a float type, substituting unsupported types+prepareFloatType :: Ord t0 => (Core.FloatType -> (Core.FloatType, ((Core.FloatValue -> Core.FloatValue), (S.Set t0))))+prepareFloatType ft =+    case ft of+      Core.FloatTypeFloat32 -> (+        Core.FloatTypeFloat32,+        (+          (\v -> case v of+            Core.FloatValueFloat32 v1 -> Core.FloatValueFloat32 v1+            _ -> v),+          Sets.empty))+      Core.FloatTypeFloat64 -> (+        Core.FloatTypeFloat64,+        (+          (\v -> case v of+            Core.FloatValueFloat64 v1 -> Core.FloatValueFloat64 v1+            _ -> v),+          Sets.empty))+-- | Prepare an integer type, substituting unsupported types+prepareIntegerType :: Core.IntegerType -> (Core.IntegerType, ((Core.IntegerValue -> Core.IntegerValue), (S.Set String)))+prepareIntegerType it =+    case it of+      Core.IntegerTypeBigint -> (+        Core.IntegerTypeInt64,+        (+          (\v -> case v of+            Core.IntegerValueBigint v1 -> Core.IntegerValueInt64 (LibLiterals.bigintToInt64 v1)+            _ -> v),+          (Sets.fromList [+            "replace arbitrary-precision integers with 64-bit integers"])))+      Core.IntegerTypeUint8 -> (+        Core.IntegerTypeInt8,+        (+          (\v -> case v of+            Core.IntegerValueUint8 v1 -> Core.IntegerValueInt8 (LibLiterals.bigintToInt8 (LibLiterals.uint8ToBigint v1))+            _ -> v),+          (Sets.fromList [+            "replace unsigned 8-bit integers with signed 8-bit integers"])))+      Core.IntegerTypeUint32 -> (+        Core.IntegerTypeInt32,+        (+          (\v -> case v of+            Core.IntegerValueUint32 v1 -> Core.IntegerValueInt32 (LibLiterals.bigintToInt32 (LibLiterals.uint32ToBigint v1))+            _ -> v),+          (Sets.fromList [+            "replace unsigned 32-bit integers with signed 32-bit integers"])))+      Core.IntegerTypeUint64 -> (+        Core.IntegerTypeInt64,+        (+          (\v -> case v of+            Core.IntegerValueUint64 v1 -> Core.IntegerValueInt64 (LibLiterals.bigintToInt64 (LibLiterals.uint64ToBigint v1))+            _ -> v),+          (Sets.fromList [+            "replace unsigned 64-bit integers with signed 64-bit integers"])))+      _ -> prepareSame it+-- | Prepare a literal type, substituting unsupported types+prepareLiteralType :: Core.LiteralType -> (Core.LiteralType, ((Core.Literal -> Core.Literal), (S.Set String)))+prepareLiteralType at =+    case at of+      Core.LiteralTypeBinary -> (+        Core.LiteralTypeString,+        (+          (\v -> case v of+            Core.LiteralBinary v1 -> Core.LiteralString (LibLiterals.binaryToString v1)+            _ -> v),+          (Sets.fromList [+            "replace binary strings with character strings"])))+      Core.LiteralTypeDecimal -> (+        Core.LiteralTypeFloat Core.FloatTypeFloat64,+        (+          (\v -> case v of+            Core.LiteralDecimal v1 -> Core.LiteralFloat (Core.FloatValueFloat64 (LibLiterals.decimalToFloat64 v1))+            _ -> v),+          (Sets.fromList [+            "replace arbitrary-precision decimal numbers with 64-bit floating-point numbers (doubles)"])))+      Core.LiteralTypeFloat v0 ->+        let result = prepareFloatType v0+            rtyp = Pairs.first result+            rep = Pairs.first (Pairs.second result)+            msgs = Pairs.second (Pairs.second result)+        in (+          Core.LiteralTypeFloat rtyp,+          (+            (\v -> case v of+              Core.LiteralFloat v1 -> Core.LiteralFloat (rep v1)+              _ -> v),+            msgs))+      Core.LiteralTypeInteger v0 ->+        let result = prepareIntegerType v0+            rtyp = Pairs.first result+            rep = Pairs.first (Pairs.second result)+            msgs = Pairs.second (Pairs.second result)+        in (+          Core.LiteralTypeInteger rtyp,+          (+            (\v -> case v of+              Core.LiteralInteger v1 -> Core.LiteralInteger (rep v1)+              _ -> v),+            msgs))+      _ -> prepareSame at+-- | Return a value unchanged with identity transform and no messages+prepareSame :: Ord t2 => (t0 -> (t0, ((t1 -> t1), (S.Set t2))))+prepareSame x = (x, ((\y -> y), Sets.empty))+-- | Prepare a type, substituting unsupported literal types+prepareType :: t0 -> Core.Type -> (Core.Type, ((Core.Term -> Core.Term), (S.Set String)))+prepareType cx typ =+    case (Strip.deannotateType typ) of+      Core.TypeLiteral v0 ->+        let result = prepareLiteralType v0+            rtyp = Pairs.first result+            rep = Pairs.first (Pairs.second result)+            msgs = Pairs.second (Pairs.second result)+        in (+          Core.TypeLiteral rtyp,+          (+            (\v -> case v of+              Core.TermLiteral v1 -> Core.TermLiteral (rep v1)+              _ -> v),+            msgs))+      _ -> prepareSame typ+-- | Normalize a term by pushing TermTypeApplication inward past TermApplication and TermLambda. This corrects structures produced by poly-let hoisting and eta expansion, where type applications from inference end up wrapping term applications or lambda abstractions instead of being directly on the polymorphic variable.+pushTypeAppsInward :: Core.Term -> Core.Term+pushTypeAppsInward term =++      let push =+              \body -> \typ -> case body of+                Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {+                  Core.annotatedTermBody = (push (Core.annotatedTermBody v0) typ),+                  Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})+                Core.TermApplication v0 -> go (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = (Core.applicationFunction v0),+                    Core.typeApplicationTermType = typ})),+                  Core.applicationArgument = (Core.applicationArgument v0)}))+                Core.TermLambda v0 -> go (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.lambdaParameter v0),+                  Core.lambdaDomain = (Core.lambdaDomain v0),+                  Core.lambdaBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = (Core.lambdaBody v0),+                    Core.typeApplicationTermType = typ}))}))+                Core.TermLet v0 -> go (Core.TermLet (Core.Let {+                  Core.letBindings = (Core.letBindings v0),+                  Core.letBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = (Core.letBody v0),+                    Core.typeApplicationTermType = typ}))}))+                _ -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                  Core.typeApplicationTermBody = body,+                  Core.typeApplicationTermType = typ})+          go =+                  \t ->+                    let forField =+                            \fld -> Core.Field {+                              Core.fieldName = (Core.fieldName fld),+                              Core.fieldTerm = (go (Core.fieldTerm fld))}+                        forCaseAlternative =+                                \alt -> Core.CaseAlternative {+                                  Core.caseAlternativeName = (Core.caseAlternativeName alt),+                                  Core.caseAlternativeHandler = (go (Core.caseAlternativeHandler alt))}+                        forLet =+                                \lt ->+                                  let mapBinding =+                                          \b -> Core.Binding {+                                            Core.bindingName = (Core.bindingName b),+                                            Core.bindingTerm = (go (Core.bindingTerm b)),+                                            Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                                  in Core.Let {+                                    Core.letBindings = (Lists.map mapBinding (Core.letBindings lt)),+                                    Core.letBody = (go (Core.letBody lt))}+                        forMap =+                                \m ->+                                  let forPair = \p -> (go (Pairs.first p), (go (Pairs.second p)))+                                  in (Maps.fromList (Lists.map forPair (Maps.toList m)))+                    in case t of+                      Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {+                        Core.annotatedTermBody = (go (Core.annotatedTermBody v0)),+                        Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})+                      Core.TermApplication v0 -> Core.TermApplication (Core.Application {+                        Core.applicationFunction = (go (Core.applicationFunction v0)),+                        Core.applicationArgument = (go (Core.applicationArgument v0))})+                      Core.TermCases v0 -> Core.TermCases (Core.CaseStatement {+                        Core.caseStatementTypeName = (Core.caseStatementTypeName v0),+                        Core.caseStatementDefault = (Optionals.map go (Core.caseStatementDefault v0)),+                        Core.caseStatementCases = (Lists.map forCaseAlternative (Core.caseStatementCases v0))})+                      Core.TermEither v0 -> Core.TermEither (Eithers.either (\l -> Left (go l)) (\r -> Right (go r)) v0)+                      Core.TermLambda v0 -> Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.lambdaParameter v0),+                        Core.lambdaDomain = (Core.lambdaDomain v0),+                        Core.lambdaBody = (go (Core.lambdaBody v0))})+                      Core.TermLet v0 -> Core.TermLet (forLet v0)+                      Core.TermList v0 -> Core.TermList (Lists.map go v0)+                      Core.TermLiteral v0 -> Core.TermLiteral v0+                      Core.TermMap v0 -> Core.TermMap (forMap v0)+                      Core.TermOptional v0 -> Core.TermOptional (Optionals.map go v0)+                      Core.TermPair v0 -> Core.TermPair (go (Pairs.first v0), (go (Pairs.second v0)))+                      Core.TermProject v0 -> Core.TermProject v0+                      Core.TermRecord v0 -> Core.TermRecord (Core.Record {+                        Core.recordTypeName = (Core.recordTypeName v0),+                        Core.recordFields = (Lists.map forField (Core.recordFields v0))})+                      Core.TermSet v0 -> Core.TermSet (Sets.fromList (Lists.map go (Sets.toList v0)))+                      Core.TermTypeApplication v0 ->+                        let body1 = go (Core.typeApplicationTermBody v0)+                        in (push body1 (Core.typeApplicationTermType v0))+                      Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda {+                        Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+                        Core.typeLambdaBody = (go (Core.typeLambdaBody v0))})+                      Core.TermInject v0 -> Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.injectionTypeName v0),+                        Core.injectionField = (forField (Core.injectionField v0))})+                      Core.TermUnit -> Core.TermUnit+                      Core.TermUnwrap v0 -> Core.TermUnwrap v0+                      Core.TermVariable v0 -> Core.TermVariable v0+                      Core.TermWrap v0 -> Core.TermWrap (Core.WrappedTerm {+                        Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0),+                        Core.wrappedTermBody = (go (Core.wrappedTermBody v0))})+      in (go term)+-- | Given a schema graph along with language constraints and a designated list of element names, adapt the graph to the language constraints, then return a corresponding type definition for each element name.+schemaGraphToDefinitions :: Coders.LanguageConstraints -> Graph.Graph -> [[Core.Name]] -> t0 -> Either Errors.Error (M.Map Core.Name Core.Type, [[Packaging.TypeDefinition]])+schemaGraphToDefinitions constraints graph nameLists cx =++      let litmap = adaptLiteralTypesMap constraints+      in (Eithers.bind (Eithers.bimap (\e -> Errors.ErrorDecoding e) (\x -> x) (Environment.graphAsTypes graph (Lexical.graphToBindings graph))) (\tmap0 -> Eithers.bind (adaptGraphSchema constraints litmap tmap0) (\tmap1 ->+        let toDef =+                \pair -> Packaging.TypeDefinition {+                  Packaging.typeDefinitionName = (Pairs.first pair),+                  Packaging.typeDefinitionMetadata = Nothing,+                  Packaging.typeDefinitionBody = Core.TypeScheme {+                    Core.typeSchemeVariables = [],+                    Core.typeSchemeBody = (Pairs.second pair),+                    Core.typeSchemeConstraints = Nothing}}+        in (Right (+          tmap1,+          (Lists.map (\names -> Lists.map toDef (Optionals.mapOptional (\n -> Optionals.map (\t -> (n, t)) (Maps.lookup n tmap1)) names)) nameLists))))))+-- | Given a target language and a source type, produce an adapter which rewrites the type and its terms according to the language's constraints. The encode direction adapts terms; the decode direction is identity.+simpleLanguageAdapter :: Coders.Language -> t0 -> Graph.Graph -> Core.Type -> Either Errors.Error (Coders.Adapter Core.Type Core.Type Core.Term Core.Term)+simpleLanguageAdapter lang cx g typ =++      let constraints = Coders.languageConstraints lang+          litmap = adaptLiteralTypesMap constraints+      in (Eithers.bind (adaptType constraints litmap typ) (\adaptedType -> Right (Coders.Adapter {+        Coders.adapterIsLossy = False,+        Coders.adapterSource = typ,+        Coders.adapterTarget = adaptedType,+        Coders.adapterCoder = Coders.Coder {+          Coders.coderEncode = (\cx2 -> \term -> adaptTerm constraints litmap cx2 g term),+          Coders.coderDecode = (\cx2 -> \term -> Right term)}})))+-- | Find a list of alternatives for a given term, if any+termAlternatives :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error [Core.Term]+termAlternatives cx graph term =+    case term of+      Core.TermAnnotated v0 ->+        let term2 = Core.annotatedTermBody v0+        in (Right [+          term2])+      Core.TermOptional v0 -> Right [+        Core.TermList (Optionals.cases v0 [] (\term2 -> [+          term2]))]+      Core.TermTypeLambda v0 ->+        let term2 = Core.typeLambdaBody v0+        in (Right [+          term2])+      Core.TermTypeApplication v0 ->+        let term2 = Core.typeApplicationTermBody v0+        in (Right [+          term2])+      Core.TermInject v0 ->+        let tname = Core.injectionTypeName v0+            field = Core.injectionField v0+            fname = Core.fieldName field+            fterm = Core.fieldTerm field+            forFieldType =+                    \ft ->+                      let ftname = Core.fieldTypeName ft+                      in Core.Field {+                        Core.fieldName = fname,+                        Core.fieldTerm = (Core.TermOptional (Logic.ifElse (Equality.equal ftname fname) (Just fterm) Nothing))}+        in (Eithers.bind (Resolution.requireUnionType cx graph tname) (\rt -> Right [+          Core.TermRecord (Core.Record {+            Core.recordTypeName = tname,+            Core.recordFields = (Lists.map forFieldType rt)})]))+      Core.TermUnit -> Right [+        Core.TermLiteral (Core.LiteralBoolean True)]+      Core.TermWrap v0 ->+        let term2 = Core.wrappedTermBody v0+        in (Right [+          term2])+      _ -> Right []+-- | Find a list of alternatives for a given type, if any+typeAlternatives :: Core.Type -> [Core.Type]+typeAlternatives type_ =+    case type_ of+      Core.TypeAnnotated v0 ->+        let type2 = Core.annotatedTypeBody v0+        in [+          type2]+      Core.TypeOptional v0 -> [+        Core.TypeList v0]+      Core.TypeUnion v0 ->+        let toOptField =+                \f -> Core.FieldType {+                  Core.fieldTypeName = (Core.fieldTypeName f),+                  Core.fieldTypeType = (Core.TypeOptional (Core.fieldTypeType f))}+            optFields = Lists.map toOptField v0+        in [+          Core.TypeRecord optFields]+      Core.TypeUnit -> [+        Core.TypeLiteral Core.LiteralTypeBoolean]+      Core.TypeVoid -> [+        Core.TypeUnit]+      _ -> []
+ src/main/haskell/Hydra/Analysis.hs view
@@ -0,0 +1,308 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Module dependency module name analysis++module Hydra.Analysis where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Arity as Arity+import qualified Hydra.Ast as Ast+import qualified Hydra.Checking as Checking+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as ErrorChecking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Predicates as Predicates+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | Add names to existing module names mapping+addNamesToModuleNames :: (Packaging.ModuleName -> t0) -> S.Set Core.Name -> Util.ModuleNames t0 -> Util.ModuleNames t0+addNamesToModuleNames encodeModuleName names ns0 =++      let nss = Sets.fromList (Optionals.cat (Lists.map Names.moduleNameOf (Sets.toList names)))+          toPair = \ns -> (ns, (encodeModuleName ns))+      in Util.ModuleNames {+        Util.moduleNamesFocus = (Util.moduleNamesFocus ns0),+        Util.moduleNamesMapping = (Maps.union (Util.moduleNamesMapping ns0) (Maps.fromList (Lists.map toPair (Sets.toList nss))))}+-- | Analyze a function term, collecting lambdas, type lambdas, lets, and type applications+analyzeFunctionTerm :: Typing.InferenceContext -> (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t0) -> t0 -> Core.Term -> Either t1 (Typing.FunctionStructure t0)+analyzeFunctionTerm cx getTC setTC env term =+    analyzeFunctionTermWith cx (\g -> \b -> Logic.ifElse (Predicates.isComplexBinding g b) (Just (Core.TermLiteral (Core.LiteralBoolean True))) Nothing) getTC setTC env term+-- | Analyze a function term with configurable binding metadata+analyzeFunctionTermWith :: Typing.InferenceContext -> (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t0) -> t0 -> Core.Term -> Either t1 (Typing.FunctionStructure t0)+analyzeFunctionTermWith cx forBinding getTC setTC env term =+    analyzeFunctionTermWithGather cx forBinding getTC setTC True env [] [] [] [] [] term+-- | Final step of the function-term walk: type-apply the body and assemble the FunctionStructure+analyzeFunctionTermWithFinish :: Typing.InferenceContext -> (t0 -> Graph.Graph) -> t0 -> [Core.Name] -> [Core.Name] -> [Core.Binding] -> [Core.Type] -> [Core.Type] -> Core.Term -> Either t1 (Typing.FunctionStructure t0)+analyzeFunctionTermWithFinish cx getTC fEnv tparams args bindings doms tapps body =++      let bodyWithTapps =+              Lists.foldl (\trm -> \typ -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                Core.typeApplicationTermBody = trm,+                Core.typeApplicationTermType = typ})) body tapps+          mcod = Eithers.either (\_ -> Nothing) (\c -> Just c) (Checking.typeOfTerm cx (getTC fEnv) bodyWithTapps)+      in (Right (Typing.FunctionStructure {+        Typing.functionStructureTypeParams = (Lists.reverse tparams),+        Typing.functionStructureParams = (Lists.reverse args),+        Typing.functionStructureBindings = bindings,+        Typing.functionStructureBody = bodyWithTapps,+        Typing.functionStructureDomains = (Lists.reverse doms),+        Typing.functionStructureCodomain = mcod,+        Typing.functionStructureEnvironment = fEnv}))+-- | Recursive step of the function-term walk: peel lambdas / type-lambdas / type-applications, accumulating params and bindings, then call analyzeFunctionTermWithFinish+analyzeFunctionTermWithGather :: Typing.InferenceContext -> (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t0) -> Bool -> t0 -> [Core.Name] -> [Core.Name] -> [Core.Binding] -> [Core.Type] -> [Core.Type] -> Core.Term -> Either t1 (Typing.FunctionStructure t0)+analyzeFunctionTermWithGather cx forBinding getTC setTC argMode gEnv tparams args bindings doms tapps t =+    case (Strip.deannotateTerm t) of+      Core.TermLambda v0 -> Logic.ifElse argMode (+        let v = Core.lambdaParameter v0+            dom = Optionals.cases (Core.lambdaDomain v0) (Core.TypeVariable (Core.Name "_")) (\x_ -> x_)+            body = Core.lambdaBody v0+            newEnv = setTC (Scoping.extendGraphForLambda (getTC gEnv) v0) gEnv+        in (analyzeFunctionTermWithGather cx forBinding getTC setTC argMode newEnv tparams (Lists.cons v args) bindings (Lists.cons dom doms) tapps body)) (analyzeFunctionTermWithFinish cx getTC gEnv tparams args bindings doms tapps t)+      Core.TermLet v0 ->+        let newBindings = Core.letBindings v0+            body = Core.letBody v0+            newEnv = setTC (Scoping.extendGraphForLet forBinding (getTC gEnv) v0) gEnv+        in (analyzeFunctionTermWithGather cx forBinding getTC setTC False newEnv tparams args (Lists.concat2 bindings newBindings) doms tapps body)+      Core.TermTypeApplication v0 ->+        let taBody = Core.typeApplicationTermBody v0+            typ = Core.typeApplicationTermType v0+        in (analyzeFunctionTermWithGather cx forBinding getTC setTC argMode gEnv tparams args bindings doms (Lists.cons typ tapps) taBody)+      Core.TermTypeLambda v0 ->+        let tvar = Core.typeLambdaParameter v0+            tlBody = Core.typeLambdaBody v0+            newEnv = setTC (Scoping.extendGraphForTypeLambda (getTC gEnv) v0) gEnv+        in (analyzeFunctionTermWithGather cx forBinding getTC setTC argMode newEnv (Lists.cons tvar tparams) args bindings doms tapps tlBody)+      _ -> analyzeFunctionTermWithFinish cx getTC gEnv tparams args bindings doms tapps t+-- | Get dependency module names from definitions+definitionDependencyModuleNames :: [Packaging.Definition] -> S.Set Packaging.ModuleName+definitionDependencyModuleNames defs =++      let defNames =+              \def -> case def of+                Packaging.DefinitionType v0 -> Dependencies.typeDependencyNames True (Core.typeSchemeBody (Packaging.typeDefinitionBody v0))+                Packaging.DefinitionTerm v0 -> Dependencies.termDependencyNames True True True (Packaging.termDefinitionBody v0)+                Packaging.DefinitionPrimitive v0 -> Dependencies.typeDependencyNames True (Core.typeSchemeBody (Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature v0)))+          allNames = Sets.unions (Lists.map defNames defs)+      in (Sets.fromList (Optionals.cat (Lists.map Names.moduleNameOf (Sets.toList allNames))))+-- | Find dependency module names in all of a set of terms (Either version)+dependencyModuleNames :: t0 -> Graph.Graph -> Bool -> Bool -> Bool -> Bool -> [Core.Binding] -> Either Errors.Error (S.Set Packaging.ModuleName)+dependencyModuleNames cx graph binds withPrims withNoms withSchema els =++      let depNames =+              \el ->+                let term = Core.bindingTerm el+                    deannotatedTerm = Strip.deannotateTerm term+                    dataNames = Dependencies.termDependencyNames binds withPrims withNoms term+                    schemaNames =+                            Logic.ifElse withSchema (Optionals.cases (Core.bindingTypeScheme el) Sets.empty (\ts -> Dependencies.typeDependencyNames True (Core.typeSchemeBody ts))) Sets.empty+                in (Logic.ifElse (Predicates.isEncodedType deannotatedTerm) (Eithers.map (\typ -> Sets.unions [+                  dataNames,+                  schemaNames,+                  (Dependencies.typeDependencyNames True typ)]) (Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\_a -> _a) (DecodeCore.type_ graph term))) (Logic.ifElse (Predicates.isEncodedTerm deannotatedTerm) (Eithers.map (\decodedTerm -> Sets.unions [+                  dataNames,+                  schemaNames,+                  (Dependencies.termDependencyNames binds withPrims withNoms decodedTerm)]) (Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\_a -> _a) (DecodeCore.term graph term))) (Right (Sets.unions [+                  dataNames,+                  schemaNames]))))+      in (Eithers.map (\namesList -> Sets.fromList (Optionals.cat (Lists.map Names.moduleNameOf (Sets.toList (Sets.unions namesList))))) (Eithers.mapList depNames els))+-- | Gather applications from a term, returning (args, baseTerm)+gatherApplications :: Core.Term -> ([Core.Term], Core.Term)+gatherApplications term =++      let go =+              \args -> \t -> case (Strip.deannotateTerm t) of+                Core.TermApplication v0 ->+                  let lhs = Core.applicationFunction v0+                      rhs = Core.applicationArgument v0+                  in (go (Lists.cons rhs args) lhs)+                _ -> (args, t)+      in (go [] term)+-- | Gather term arguments, stripping type-level constructs+gatherArgs :: Core.Term -> [Core.Term] -> (Core.Term, [Core.Term])+gatherArgs term args =+    case (Strip.deannotateTerm term) of+      Core.TermApplication v0 ->+        let lhs = Core.applicationFunction v0+            rhs = Core.applicationArgument v0+        in (gatherArgs lhs (Lists.cons rhs args))+      Core.TermTypeLambda v0 ->+        let body = Core.typeLambdaBody v0+        in (gatherArgs body args)+      Core.TermTypeApplication v0 ->+        let body = Core.typeApplicationTermBody v0+        in (gatherArgs body args)+      _ -> (term, args)+-- | Gather term and type arguments from a term+gatherArgsWithTypeApps :: Core.Term -> [Core.Term] -> [Core.Type] -> (Core.Term, ([Core.Term], [Core.Type]))+gatherArgsWithTypeApps term args tyArgs =+    case (Strip.deannotateTerm term) of+      Core.TermApplication v0 ->+        let lhs = Core.applicationFunction v0+            rhs = Core.applicationArgument v0+        in (gatherArgsWithTypeApps lhs (Lists.cons rhs args) tyArgs)+      Core.TermTypeLambda v0 ->+        let body = Core.typeLambdaBody v0+        in (gatherArgsWithTypeApps body args tyArgs)+      Core.TermTypeApplication v0 ->+        let body = Core.typeApplicationTermBody v0+            typ = Core.typeApplicationTermType v0+        in (gatherArgsWithTypeApps body args (Lists.cons typ tyArgs))+      _ -> (term, (args, tyArgs))+-- | Check if a term body is self-tail-recursive with respect to a function name+isSelfTailRecursive :: Core.Name -> Core.Term -> Bool+isSelfTailRecursive funcName body =++      let callsSelf = Logic.not (Variables.isFreeVariableInTerm funcName body)+      in (Logic.ifElse callsSelf (isTailRecursiveInTailPosition funcName body) False)+-- | Check if a term can be encoded as a simple assignment+isSimpleAssignment :: Core.Term -> Bool+isSimpleAssignment term =+    case term of+      Core.TermAnnotated v0 -> isSimpleAssignment (Core.annotatedTermBody v0)+      Core.TermLambda _ -> False+      Core.TermLet _ -> False+      Core.TermTypeLambda _ -> False+      Core.TermTypeApplication v0 -> isSimpleAssignment (Core.typeApplicationTermBody v0)+      _ ->+        let baseTerm = Pairs.first (gatherArgs term [])+        in case baseTerm of+          Core.TermCases _ -> False+          _ -> True+-- | Check that all self-references are in tail position+isTailRecursiveInTailPosition :: Core.Name -> Core.Term -> Bool+isTailRecursiveInTailPosition funcName term =++      let stripped = Strip.deannotateAndDetypeTerm term+      in case stripped of+        Core.TermApplication _ ->+          let gathered = gatherApplications stripped+              gatherArgs = Pairs.first gathered+              gatherFun = Pairs.second gathered+              strippedFun = Strip.deannotateAndDetypeTerm gatherFun+          in case strippedFun of+            Core.TermVariable v1 -> Logic.ifElse (Equality.equal v1 funcName) (+              let argsNoFunc = Lists.foldl (\ok -> \arg -> Logic.and ok (Variables.isFreeVariableInTerm funcName arg)) True gatherArgs+                  argsNoLambda =+                          Lists.foldl (\ok -> \arg -> Logic.and ok (Logic.not (Rewriting.foldOverTerm Coders.TraversalOrderPre (\found -> \t -> Logic.or found (case t of+                            Core.TermLambda v2 ->+                              let ignore = Core.lambdaBody v2+                              in True+                            _ -> False)) False arg))) True gatherArgs+              in (Logic.and argsNoFunc argsNoLambda)) (Variables.isFreeVariableInTerm funcName term)+            Core.TermCases v1 ->+              let cases_ = Core.caseStatementCases v1+                  dflt = Core.caseStatementDefault v1+                  branchesOk =+                          Lists.foldl (\ok -> \field -> Logic.and ok (isTailRecursiveInTailPosition funcName (Core.caseAlternativeHandler field))) True cases_+                  dfltOk = Optionals.cases dflt True (\d -> isTailRecursiveInTailPosition funcName d)+                  argsOk = Lists.foldl (\ok -> \arg -> Logic.and ok (Variables.isFreeVariableInTerm funcName arg)) True gatherArgs+              in (Logic.and (Logic.and branchesOk dfltOk) argsOk)+            _ -> Variables.isFreeVariableInTerm funcName term+        Core.TermLambda v0 -> isTailRecursiveInTailPosition funcName (Core.lambdaBody v0)+        Core.TermLet v0 ->+          let bindingsOk =+                  Lists.foldl (\ok -> \b -> Logic.and ok (Variables.isFreeVariableInTerm funcName (Core.bindingTerm b))) True (Core.letBindings v0)+          in (Logic.and bindingsOk (isTailRecursiveInTailPosition funcName (Core.letBody v0)))+        _ -> Variables.isFreeVariableInTerm funcName term+-- | Check whether a module contains any binary literal values+moduleContainsBinaryLiterals :: Packaging.Module -> Bool+moduleContainsBinaryLiterals mod =++      let checkTerm =+              \found -> \term -> Logic.or found (case term of+                Core.TermLiteral v0 -> case v0 of+                  Core.LiteralBinary _ -> True+                  _ -> False+                _ -> False)+          termContainsBinary = \term -> Rewriting.foldOverTerm Coders.TraversalOrderPre checkTerm False term+          defTerms =+                  Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Packaging.termDefinitionBody v0)+                    _ -> Nothing) (Packaging.moduleDefinitions mod))+      in (Lists.foldl (\acc -> \t -> Logic.or acc (termContainsBinary t)) False defTerms)+-- | Check whether a module contains any decimal literal values+moduleContainsDecimalLiterals :: Packaging.Module -> Bool+moduleContainsDecimalLiterals mod =++      let checkTerm =+              \found -> \term -> Logic.or found (case term of+                Core.TermLiteral v0 -> case v0 of+                  Core.LiteralDecimal _ -> True+                  _ -> False+                _ -> False)+          termContainsDecimal = \term -> Rewriting.foldOverTerm Coders.TraversalOrderPre checkTerm False term+          defTerms =+                  Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Packaging.termDefinitionBody v0)+                    _ -> Nothing) (Packaging.moduleDefinitions mod))+      in (Lists.foldl (\acc -> \t -> Logic.or acc (termContainsDecimal t)) False defTerms)+-- | Find dependency module names in all elements of a module, excluding the module's own module name (Either version)+moduleDependencyModuleNames :: t0 -> Graph.Graph -> Bool -> Bool -> Bool -> Bool -> Packaging.Module -> Either Errors.Error (S.Set Packaging.ModuleName)+moduleDependencyModuleNames cx graph binds withPrims withNoms withSchema mod =++      let allBindings =+              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)))+                Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                  Core.bindingName = (Packaging.termDefinitionName v0),+                  Core.bindingTerm = (Packaging.termDefinitionBody v0),+                  Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                _ -> Nothing) (Packaging.moduleDefinitions mod))+      in (Eithers.map (\deps -> Sets.delete (Packaging.moduleName mod) deps) (dependencyModuleNames cx graph binds withPrims withNoms withSchema allBindings))+-- | Create module names mapping for definitions+moduleNamesForDefinitions :: (Packaging.ModuleName -> t0) -> Packaging.ModuleName -> [Packaging.Definition] -> Util.ModuleNames t0+moduleNamesForDefinitions encodeModuleName focusNs defs =++      let nss = Sets.delete focusNs (definitionDependencyModuleNames defs)+          toPair = \ns -> (ns, (encodeModuleName ns))+      in Util.ModuleNames {+        Util.moduleNamesFocus = (toPair focusNs),+        Util.moduleNamesMapping = (Maps.fromList (Lists.map toPair (Sets.toList nss)))}
+ src/main/haskell/Hydra/Annotations.hs view
@@ -0,0 +1,216 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Utilities for reading and writing type and term annotations++module Hydra.Annotations where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+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.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Aggregate annotations from nested structures+aggregateAnnotations :: Ord t2 => ((t0 -> Maybe t1) -> (t1 -> t0) -> (t1 -> M.Map t2 t3) -> t0 -> M.Map t2 t3)+aggregateAnnotations getValue getX getAnns t =++      let toPairs =+              \rest -> \t2 -> Optionals.cases (getValue t2) rest (\yy -> toPairs (Lists.cons (Maps.toList (getAnns yy)) rest) (getX yy))+      in (Maps.fromList (Lists.concat (toPairs [] t)))+-- | Extract comments/description from a Binding+commentsFromBinding :: t0 -> Graph.Graph -> Core.Binding -> Either Errors.Error (Maybe String)+commentsFromBinding cx g b = getTermDescription cx g (Core.bindingTerm b)+-- | Extract comments/description from a FieldType+commentsFromFieldType :: t0 -> Graph.Graph -> Core.FieldType -> Either Errors.Error (Maybe String)+commentsFromFieldType cx g ft = getTypeDescription cx g (Core.fieldTypeType ft)+-- | Project a Map<Name, Term> out of an annotation Term. For a TermMap with TermVariable-shaped keys (or, transitionally, TermWrap-encoded Name keys), returns those (Name, value) entries; for any other shape, returns the empty map.+getAnnotationMap :: Core.Term -> M.Map Core.Name Core.Term+getAnnotationMap t =++      let extractName =+              \k -> case k of+                Core.TermVariable v0 -> Just v0+                Core.TermWrap v0 -> case (Core.wrappedTermBody v0) of+                  Core.TermLiteral v1 -> case v1 of+                    Core.LiteralString v2 -> Just (Core.Name v2)+                    _ -> Nothing+                  _ -> Nothing+                _ -> Nothing+          fromEntry =+                  \p ->+                    let k = Pairs.first p+                        v = Pairs.second p+                    in (Optionals.map (\n -> (n, v)) (extractName k))+      in case t of+        Core.TermMap v0 -> Maps.fromList (Optionals.cat (Lists.map fromEntry (Maps.toList v0)))+        _ -> Maps.empty+-- | Get description from annotations map (Either version)+getDescription :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.Error (Maybe String)+getDescription cx graph anns =+    Optionals.cases (Maps.lookup (Core.Name "description") anns) (Right Nothing) (\term -> Eithers.map Optionals.pure (ExtractCore.string graph term))+-- | Get a term annotation+getTermAnnotation :: Core.Name -> Core.Term -> Maybe Core.Term+getTermAnnotation key term = Maps.lookup key (termAnnotationInternal term)+-- | Get term description (Either version)+getTermDescription :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error (Maybe String)+getTermDescription cx graph term =++      let peel =+              \t -> case t of+                Core.TermTypeLambda v0 -> peel (Core.typeLambdaBody v0)+                Core.TermTypeApplication v0 -> peel (Core.typeApplicationTermBody v0)+                _ -> t+      in (getDescription cx graph (termAnnotationInternal (peel term)))+-- | Get type from annotations+getType :: Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.DecodingError (Maybe Core.Type)+getType graph anns =+    Optionals.cases (Maps.lookup Constants.keyType anns) (Right Nothing) (\dat -> Eithers.map Optionals.pure (DecodeCore.type_ graph dat))+-- | Get a type annotation+getTypeAnnotation :: Core.Name -> Core.Type -> Maybe Core.Term+getTypeAnnotation key typ = Maps.lookup key (typeAnnotationInternal typ)+-- | Get type classes from term. Each Set Name contains bare class identifiers (#275).+getTypeClasses :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error (M.Map Core.Name (S.Set Core.Name))+getTypeClasses cx graph term =++      let decodeName = \term2 -> Eithers.bimap (\de -> Errors.ErrorDecoding de) (\x -> x) (DecodeCore.name graph term2)+      in (Optionals.cases (getTermAnnotation Constants.keyClasses term) (Right Maps.empty) (\term2 -> ExtractCore.map decodeName (ExtractCore.setOf decodeName graph) graph term2))+-- | Get type description (Either version)+getTypeDescription :: t0 -> Graph.Graph -> Core.Type -> Either Errors.Error (Maybe String)+getTypeDescription cx graph typ = getDescription cx graph (typeAnnotationInternal typ)+-- | Check if annotations contain description+hasDescription :: M.Map Core.Name t0 -> Bool+hasDescription anns = Optionals.isGiven (Maps.lookup Constants.keyDescription anns)+-- | Check if type has description+hasTypeDescription :: Core.Type -> Bool+hasTypeDescription typ = hasDescription (typeAnnotationInternal typ)+-- | For a typed term, decide whether a coder should encode it as a native type expression, or as a Hydra type expression.+isNativeType :: Core.Binding -> Bool+isNativeType el =++      let isFlaggedAsFirstClassType =+              Optionals.fromOptional False (Optionals.map (\_ -> True) (getTermAnnotation Constants.keyFirstClassType (Core.bindingTerm el)))+      in (Optionals.cases (Core.bindingTypeScheme el) False (\ts -> Logic.and (Equality.equal ts (Core.TypeScheme {+        Core.typeSchemeVariables = [],+        Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+        Core.typeSchemeConstraints = Nothing})) (Logic.not isFlaggedAsFirstClassType)))+-- | Normalize term annotations+normalizeTermAnnotations :: Core.Term -> Core.Term+normalizeTermAnnotations term =++      let anns = termAnnotationInternal term+          stripped = Strip.deannotateTerm term+      in (Logic.ifElse (Maps.null anns) stripped (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = stripped,+        Core.annotatedTermAnnotation = (wrapAnnotationMap anns)})))+-- | Normalize type annotations+normalizeTypeAnnotations :: Core.Type -> Core.Type+normalizeTypeAnnotations typ =++      let anns = typeAnnotationInternal typ+          stripped = Strip.deannotateType typ+      in (Logic.ifElse (Maps.null anns) stripped (Core.TypeAnnotated (Core.AnnotatedType {+        Core.annotatedTypeBody = stripped,+        Core.annotatedTypeAnnotation = (wrapAnnotationMap anns)})))+-- | Set annotation in map+setAnnotation :: Ord t0 => (t0 -> Maybe t1 -> M.Map t0 t1 -> M.Map t0 t1)+setAnnotation key val m = Maps.alter (\_ -> val) key m+-- | Set description in annotations+setDescription :: Maybe String -> M.Map Core.Name Core.Term -> M.Map Core.Name Core.Term+setDescription d =+    setAnnotation Constants.keyDescription (Optionals.map (\arg_ -> (\x -> Core.TermLiteral x) ((\x -> Core.LiteralString x) arg_)) d)+-- | Set term annotation+setTermAnnotation :: Core.Name -> Maybe Core.Term -> Core.Term -> Core.Term+setTermAnnotation key val term =++      let term_ = Strip.deannotateTerm term+          anns = setAnnotation key val (termAnnotationInternal term)+      in (Logic.ifElse (Maps.null anns) term_ (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = term_,+        Core.annotatedTermAnnotation = (wrapAnnotationMap anns)})))+-- | Set term description+setTermDescription :: Maybe String -> Core.Term -> Core.Term+setTermDescription d =+    setTermAnnotation Constants.keyDescription (Optionals.map (\s -> Core.TermLiteral (Core.LiteralString s)) d)+-- | Set type in annotations+setType :: Maybe Core.Type -> M.Map Core.Name Core.Term -> M.Map Core.Name Core.Term+setType mt = setAnnotation Constants.keyType (Optionals.map EncodeCore.type_ mt)+-- | Set type annotation+setTypeAnnotation :: Core.Name -> Maybe Core.Term -> Core.Type -> Core.Type+setTypeAnnotation key val typ =++      let typ_ = Strip.deannotateType typ+          anns = setAnnotation key val (typeAnnotationInternal typ)+      in (Logic.ifElse (Maps.null anns) typ_ (Core.TypeAnnotated (Core.AnnotatedType {+        Core.annotatedTypeBody = typ_,+        Core.annotatedTypeAnnotation = (wrapAnnotationMap anns)})))+-- | Set type classes on term. The Set Name carries bare class identifiers (#275).+setTypeClasses :: M.Map Core.Name (S.Set Core.Name) -> Core.Term -> Core.Term+setTypeClasses m term =++      let encodePair =+              \nameClasses ->+                let name = Pairs.first nameClasses+                    classes = Pairs.second nameClasses+                in (EncodeCore.name name, (Core.TermSet (Sets.fromList (Lists.map EncodeCore.name (Sets.toList classes)))))+          encoded = Logic.ifElse (Maps.null m) Nothing (Just (Core.TermMap (Maps.fromList (Lists.map encodePair (Maps.toList m)))))+      in (setTermAnnotation Constants.keyClasses encoded term)+-- | Set type description+setTypeDescription :: Maybe String -> Core.Type -> Core.Type+setTypeDescription d =+    setTypeAnnotation Constants.keyDescription (Optionals.map (\arg_ -> (\x -> Core.TermLiteral x) ((\x -> Core.LiteralString x) arg_)) d)+-- | Get internal term annotations+termAnnotationInternal :: Core.Term -> M.Map Core.Name Core.Term+termAnnotationInternal term =++      let getAnn =+              \t -> case t of+                Core.TermAnnotated v0 -> Just v0+                _ -> Nothing+      in (aggregateAnnotations getAnn (\at -> Core.annotatedTermBody at) (\at -> getAnnotationMap (Core.annotatedTermAnnotation at)) term)+-- | Get internal type annotations+typeAnnotationInternal :: Core.Type -> M.Map Core.Name Core.Term+typeAnnotationInternal typ =++      let getAnn =+              \t -> case t of+                Core.TypeAnnotated v0 -> Just v0+                _ -> Nothing+      in (aggregateAnnotations getAnn (\at -> Core.annotatedTypeBody at) (\at -> getAnnotationMap (Core.annotatedTypeAnnotation at)) typ)+-- | Wrap a Map<Name, Term> as a TermMap annotation. Each Name key becomes a TermVariable.+wrapAnnotationMap :: M.Map Core.Name Core.Term -> Core.Term+wrapAnnotationMap m =+    Core.TermMap (Maps.fromList (Lists.map (\p -> (Core.TermVariable (Pairs.first p), (Pairs.second p))) (Maps.toList m)))
+ src/main/haskell/Hydra/Arity.hs view
@@ -0,0 +1,66 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Functions dealing with arguments and arity.++module Hydra.Arity where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Math as Math+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Find the arity (expected number of arguments) of a primitive constant or function+primitiveArity :: Graph.Primitive -> Int+primitiveArity prim =+    Lists.length (Typing.termSignatureParameters (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim)))+-- | Find the arity (expected number of arguments) of a term+termArity :: Core.Term -> Int+termArity x =+    case x of+      Core.TermApplication v0 -> (\arg_2 -> (\xapp -> Math.sub xapp 1) (termArity arg_2)) (Core.applicationFunction v0)+      Core.TermCases _ -> 1+      Core.TermLambda v0 -> (\i -> Math.add 1 i) (termArity (Core.lambdaBody v0))+      Core.TermProject _ -> 1+      Core.TermUnwrap _ -> 1+      _ -> 0+-- | Find the arity (expected number of arguments) of a type+typeArity :: Core.Type -> Int+typeArity x =+    case x of+      Core.TypeAnnotated v0 -> typeArity (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> typeArity (Core.applicationTypeFunction v0)+      Core.TypeForall v0 -> typeArity (Core.forallTypeBody v0)+      Core.TypeFunction v0 -> Math.add 1 (typeArity (Core.functionTypeCodomain v0))+      _ -> 0+-- | Find the arity (expected number of arguments) of a type scheme+typeSchemeArity :: Core.TypeScheme -> Int+typeSchemeArity arg_ = typeArity (Core.typeSchemeBody arg_)+-- | Uncurry a type expression into a list of types, turning a function type a -> b into cons a (uncurryType b)+uncurryType :: Core.Type -> [Core.Type]+uncurryType t =+    case t of+      Core.TypeAnnotated v0 -> uncurryType (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> uncurryType (Core.applicationTypeFunction v0)+      Core.TypeForall v0 -> uncurryType (Core.forallTypeBody v0)+      Core.TypeFunction v0 -> Lists.cons (Core.functionTypeDomain v0) (uncurryType (Core.functionTypeCodomain v0))+      _ -> [+        t]
+ src/main/haskell/Hydra/Ast.hs view
@@ -0,0 +1,182 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A model which provides a common syntax tree for Hydra serializers++module Hydra.Ast where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Operator associativity+data Associativity =+  AssociativityNone |+  AssociativityLeft |+  AssociativityRight |+  AssociativityBoth+  deriving (Eq, Ord, Read, Show)+_Associativity = Core.Name "hydra.ast.Associativity"+_Associativity_none = Core.Name "none"+_Associativity_left = Core.Name "left"+_Associativity_right = Core.Name "right"+_Associativity_both = Core.Name "both"+-- | Formatting option for code blocks+data BlockStyle =+  BlockStyle {+    -- | An optional indentation string+    blockStyleIndent :: (Maybe String),+    -- | Whether to place a newline before the content+    blockStyleNewlineBeforeContent :: Bool,+    -- | Whether to place a newline after the content+    blockStyleNewlineAfterContent :: Bool}+  deriving (Eq, Ord, Read, Show)+_BlockStyle = Core.Name "hydra.ast.BlockStyle"+_BlockStyle_indent = Core.Name "indent"+_BlockStyle_newlineBeforeContent = Core.Name "newlineBeforeContent"+_BlockStyle_newlineAfterContent = Core.Name "newlineAfterContent"+-- | An expression enclosed by brackets+data BracketExpr =+  BracketExpr {+    -- | The bracket pair enclosing the expression+    bracketExprBrackets :: Brackets,+    -- | The expression within the brackets+    bracketExprEnclosed :: Expr,+    -- | The formatting style for the bracketed block+    bracketExprStyle :: BlockStyle}+  deriving (Eq, Ord, Read, Show)+_BracketExpr = Core.Name "hydra.ast.BracketExpr"+_BracketExpr_brackets = Core.Name "brackets"+_BracketExpr_enclosed = Core.Name "enclosed"+_BracketExpr_style = Core.Name "style"+-- | Matching open and close bracket symbols+data Brackets =+  Brackets {+    -- | The opening bracket symbol+    bracketsOpen :: Symbol,+    -- | The closing bracket symbol+    bracketsClose :: Symbol}+  deriving (Eq, Ord, Read, Show)+_Brackets = Core.Name "hydra.ast.Brackets"+_Brackets_open = Core.Name "open"+_Brackets_close = Core.Name "close"+-- | An abstract expression+data Expr =+  -- | A constant symbol+  ExprConst Symbol |+  -- | An indented expression+  ExprIndent IndentedExpression |+  -- | An operator expression+  ExprOp OpExpr |+  -- | A bracketed expression+  ExprBrackets BracketExpr |+  -- | A sequence of expressions joined by a separator, treated as structural layout (not subject to parenthesization)+  ExprSeq SeqExpr+  deriving (Eq, Ord, Read, Show)+_Expr = Core.Name "hydra.ast.Expr"+_Expr_const = Core.Name "const"+_Expr_indent = Core.Name "indent"+_Expr_op = Core.Name "op"+_Expr_brackets = Core.Name "brackets"+_Expr_seq = Core.Name "seq"+-- | Any of several indentation styles+data IndentStyle =+  -- | Indent all lines with the given string+  IndentStyleAllLines String |+  -- | Indent only lines after the first with the given string+  IndentStyleSubsequentLines String+  deriving (Eq, Ord, Read, Show)+_IndentStyle = Core.Name "hydra.ast.IndentStyle"+_IndentStyle_allLines = Core.Name "allLines"+_IndentStyle_subsequentLines = Core.Name "subsequentLines"+-- | An expression indented in a certain style+data IndentedExpression =+  IndentedExpression {+    -- | The indentation style+    indentedExpressionStyle :: IndentStyle,+    -- | The expression to be indented+    indentedExpressionExpr :: Expr}+  deriving (Eq, Ord, Read, Show)+_IndentedExpression = Core.Name "hydra.ast.IndentedExpression"+_IndentedExpression_style = Core.Name "style"+_IndentedExpression_expr = Core.Name "expr"+-- | An operator symbol+data Op =+  Op {+    -- | The operator symbol+    opSymbol :: Symbol,+    -- | The padding around the operator+    opPadding :: Padding,+    -- | The precedence of the operator+    opPrecedence :: Precedence,+    -- | The associativity of the operator+    opAssociativity :: Associativity}+  deriving (Eq, Ord, Read, Show)+_Op = Core.Name "hydra.ast.Op"+_Op_symbol = Core.Name "symbol"+_Op_padding = Core.Name "padding"+_Op_precedence = Core.Name "precedence"+_Op_associativity = Core.Name "associativity"+-- | An operator expression+data OpExpr =+  OpExpr {+    -- | The operator+    opExprOp :: Op,+    -- | The left-hand side operand+    opExprLhs :: Expr,+    -- | The right-hand side operand+    opExprRhs :: Expr}+  deriving (Eq, Ord, Read, Show)+_OpExpr = Core.Name "hydra.ast.OpExpr"+_OpExpr_op = Core.Name "op"+_OpExpr_lhs = Core.Name "lhs"+_OpExpr_rhs = Core.Name "rhs"+-- | Left and right padding for an operator+data Padding =+  Padding {+    -- | Padding to the left of the operator+    paddingLeft :: Ws,+    -- | Padding to the right of the operator+    paddingRight :: Ws}+  deriving (Eq, Ord, Read, Show)+_Padding = Core.Name "hydra.ast.Padding"+_Padding_left = Core.Name "left"+_Padding_right = Core.Name "right"+-- | Operator precedence+newtype Precedence =+  Precedence {+    unPrecedence :: Int}+  deriving (Eq, Ord, Read, Show)+_Precedence = Core.Name "hydra.ast.Precedence"+-- | A sequence of expressions joined by a separator operator. Unlike OpExpr, parenthesize ignores SeqExpr boundaries.+data SeqExpr =+  SeqExpr {+    -- | The separator operator+    seqExprOp :: Op,+    -- | The expressions to join+    seqExprElements :: [Expr]}+  deriving (Eq, Ord, Read, Show)+_SeqExpr = Core.Name "hydra.ast.SeqExpr"+_SeqExpr_op = Core.Name "op"+_SeqExpr_elements = Core.Name "elements"+-- | Any symbol+newtype Symbol =+  Symbol {+    unSymbol :: String}+  deriving (Eq, Ord, Read, Show)+_Symbol = Core.Name "hydra.ast.Symbol"+-- | One of several classes of whitespace+data Ws =+  -- | No whitespace+  WsNone |+  -- | A single space+  WsSpace |+  -- | A line break+  WsBreak |+  -- | A line break followed by indentation+  WsBreakAndIndent String |+  -- | Two line breaks+  WsDoubleBreak+  deriving (Eq, Ord, Read, Show)+_Ws = Core.Name "hydra.ast.Ws"+_Ws_none = Core.Name "none"+_Ws_space = Core.Name "space"+_Ws_break = Core.Name "break"+_Ws_breakAndIndent = Core.Name "breakAndIndent"+_Ws_doubleBreak = Core.Name "doubleBreak"
+ src/main/haskell/Hydra/Checking.hs view
@@ -0,0 +1,689 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Type checking and type reconstruction (type-of) for the results of Hydra unification and inference++module Hydra.Checking where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Extract.Core as ExtractCore+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Resolution as Resolution+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Show.Variants as ShowVariants+import qualified Hydra.Strip as Strip+import qualified Hydra.Substitution as Substitution+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | True if every element of the list is equal to every other element (vacuously true for the empty list)+allEqual :: Eq t0 => ([t0] -> Bool)+allEqual els =+    Optionals.cases (Lists.uncons els) True (\uc ->+      let h = Pairs.first uc+          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 cx tx typeArgs t =+    Optionals.cases (Lists.uncons typeArgs) (Right t) (\uc ->+      let ah = Pairs.first uc+          at = Pairs.second uc+      in case t of+        Core.TypeForall v0 ->+          let v = Core.forallTypeParameter v0+              tbody = Core.forallTypeBody v0+          in (applyTypeArgumentsToType cx tx at (Substitution.substInType (Typing.TypeSubst (Maps.singleton v ah)) tbody))+        _ -> 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),+            ". Context has vars: {",+            (Strings.intercalate ", " (Lists.map Core.unName (Maps.keys (Graph.graphBoundTypes tx)))),+            "}"])}))))+-- | Check that a term has no unbound type variables (Either version)+checkForUnboundTypeVariables :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error ()+checkForUnboundTypeVariables cx tx term0 =++      let svars = Sets.fromList (Maps.keys (Graph.graphSchemaTypes tx))+          checkRecursive =+                  \vars -> \trace -> \lbinding -> \term ->+                    let recurse = checkRecursive vars trace lbinding+                        dflt = Eithers.bind (Eithers.mapList recurse (Rewriting.subterms term)) (\_ -> Right ())+                        check =+                                \typ ->+                                  let freevars = Variables.freeVariablesInType typ+                                      badvars = Sets.difference (Sets.difference freevars vars) svars+                                  in (Logic.ifElse (Sets.null badvars) (Right ()) (Left (Errors.ErrorChecking (Checking.CheckingErrorUnboundTypeVariables (Checking.UnboundTypeVariablesError {+                                    Checking.unboundTypeVariablesErrorVariables = badvars,+                                    Checking.unboundTypeVariablesErrorType = typ})))))+                        checkOptional = \m -> Eithers.bind (Eithers.mapOptional check m) (\_ -> Right ())+                    in case term of+                      Core.TermLambda v0 -> Eithers.bind (checkOptional (Core.lambdaDomain v0)) (\_ -> recurse (Core.lambdaBody v0))+                      Core.TermLet v0 ->+                        let forBinding =+                                \b ->+                                  let bterm = Core.bindingTerm b+                                      newVars =+                                              Optionals.cases (Core.bindingTypeScheme b) vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts)))+                                      newTrace = Lists.cons (Core.unName (Core.bindingName b)) trace+                                  in (checkRecursive newVars newTrace (Just b) bterm)+                        in (Eithers.bind (Eithers.mapList forBinding (Core.letBindings v0)) (\_ -> recurse (Core.letBody v0)))+                      Core.TermTypeApplication v0 -> Eithers.bind (check (Core.typeApplicationTermType v0)) (\_ -> recurse (Core.typeApplicationTermBody v0))+                      Core.TermTypeLambda v0 -> Eithers.bind (check (Core.TypeVariable (Core.typeLambdaParameter v0))) (\_ -> recurse (Core.typeLambdaBody v0))+                      _ -> dflt+      in (checkRecursive Sets.empty [+        "top level"] Nothing term0)+-- | Check that a nominal type is applied to the correct number of type arguments (Either version)+checkNominalApplication :: Typing.InferenceContext -> Graph.Graph -> Core.Name -> [Core.Type] -> Either Errors.Error ((), Typing.InferenceContext)+checkNominalApplication cx tx tname typeArgs =+    Eithers.bind (Resolution.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\result ->+      let schemaType = Pairs.first result+          cx2 = Pairs.second result+          vars = Core.typeSchemeVariables schemaType+          varslen = Lists.length vars+          argslen = Lists.length typeArgs+      in (Logic.ifElse (Equality.equal varslen argslen) (Right ((), cx2)) (Left (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError {+        Checking.typeArityMismatchErrorType = (Core.TypeVariable tname),+        Checking.typeArityMismatchErrorExpectedArity = varslen,+        Checking.typeArityMismatchErrorActualArity = argslen,+        Checking.typeArityMismatchErrorTypeArguments = typeArgs}))))))+-- | Ensure all types in a list are equal and return the common type+checkSameType :: t0 -> Graph.Graph -> String -> [Core.Type] -> Either Errors.Error Core.Type+checkSameType cx tx desc types =++      let unequalErr =+              Left (Errors.ErrorChecking (Checking.CheckingErrorUnequalTypes (Checking.UnequalTypesError {+                Checking.unequalTypesErrorTypes = types,+                Checking.unequalTypesErrorDescription = desc})))+      in (Logic.ifElse (typesAllEffectivelyEqual tx types) (Optionals.cases (Lists.maybeHead types) unequalErr (\t -> Right t)) unequalErr)+-- | Check that a term has the expected type+checkType :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Core.Type -> Either Errors.Error ()+checkType cx tx term typ =++      let vars = Graph.graphTypeVariables tx+      in (Logic.ifElse Constants.debugInference (Eithers.bind (Eithers.map (\_p -> Pairs.first _p) (typeOf cx tx [] term)) (\t0 -> Logic.ifElse (typesEffectivelyEqual tx t0 typ) (Right ()) (Left (Errors.ErrorChecking (Checking.CheckingErrorTypeMismatch (Checking.TypeMismatchError {+        Checking.typeMismatchErrorExpectedType = typ,+        Checking.typeMismatchErrorActualType = t0})))))) (Right ()))+-- | Sanity-check a type substitution arising from unification. Specifically, check that schema types have not been inappropriately unified with type variables inferred from terms.+checkTypeSubst :: t0 -> Graph.Graph -> Typing.TypeSubst -> Either Errors.Error Typing.TypeSubst+checkTypeSubst cx tx subst =++      let s = Typing.unTypeSubst subst+          vars = Sets.fromList (Maps.keys s)+          suspectVars = Sets.intersection vars (Sets.fromList (Maps.keys (Graph.graphSchemaTypes tx)))+          isNominal =+                  \ts -> case (Strip.deannotateType (Core.typeSchemeBody ts)) of+                    Core.TypeRecord _ -> True+                    Core.TypeUnion _ -> True+                    Core.TypeWrap _ -> True+                    _ -> False+          badVars =+                  Sets.fromList (Lists.filter (\v -> Optionals.cases (Lexical.dereferenceSchemaType v (Graph.graphSchemaTypes tx)) False isNominal) (Sets.toList suspectVars))+          badPairs = Lists.filter (\p -> Sets.member (Pairs.first p) badVars) (Maps.toList s)+          printPair = \p -> Strings.cat2 (Strings.cat2 (Core.unName (Pairs.first p)) " --> ") (ShowCore.type_ (Pairs.second p))+      in (Logic.ifElse (Sets.null badVars) (Right subst) (Left (Errors.ErrorChecking (Checking.CheckingErrorIncorrectUnification (Checking.IncorrectUnificationError {+        Checking.incorrectUnificationErrorSubstitution = subst})))))+-- | Check that all type variables in a type are bound. NOTE: This check is currently disabled to allow phantom type variables from polymorphic instantiation to pass through. The proper fix is to ensure `typeOf` doesn't create fresh variables for post-inference code.+checkTypeVariables :: t0 -> t1 -> ()+checkTypeVariables _tx _typ = ()+-- | Check if a type contains any type variable from the current scope+containsInScopeTypeVars :: Graph.Graph -> Core.Type -> Bool+containsInScopeTypeVars tx t =++      let vars = Graph.graphTypeVariables tx+          freeVars = Variables.freeVariablesInTypeSimple t+      in (Logic.not (Sets.null (Sets.intersection vars freeVars)))+-- | Normalize free type variables in a type to canonical names based on order of first occurrence. This allows comparing types that differ only in the naming of free type variables.+normalizeTypeFreeVars :: Core.Type -> Core.Type+normalizeTypeFreeVars typ =++      let collectVars =+              \acc -> \t -> case t of+                Core.TypeVariable v0 -> Logic.ifElse (Maps.member v0 acc) acc (Maps.insert v0 (Core.Name (Strings.cat2 "_tv" (Literals.showInt32 (Maps.size acc)))) acc)+                _ -> acc+          subst = Rewriting.foldOverType Coders.TraversalOrderPre collectVars Maps.empty typ+      in (Variables.substituteTypeVariables subst typ)+-- | Get the bound types from a graph as a type environment+toFContext :: Graph.Graph -> M.Map Core.Name Core.Type+toFContext cx = Maps.map Scoping.typeSchemeToFType (Graph.graphBoundTypes cx)+-- | Check whether two lists of types are effectively equal, disregarding type aliases+typeListsEffectivelyEqual :: Graph.Graph -> [Core.Type] -> [Core.Type] -> Bool+typeListsEffectivelyEqual tx tlist1 tlist2 =+    Logic.ifElse (Equality.equal (Lists.length tlist1) (Lists.length tlist2)) (Lists.foldl Logic.and True (Lists.zipWith (typesEffectivelyEqual tx) tlist1 tlist2)) False+-- | Given a type context, reconstruct the type of a System F term+typeOf :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOf cx tx typeArgs term =++      let cx1 = cx+      in case term of+        Core.TermAnnotated v0 -> typeOfAnnotatedTerm cx1 tx typeArgs v0+        Core.TermApplication v0 -> typeOfApplication cx1 tx typeArgs v0+        Core.TermCases v0 -> typeOfCaseStatement cx1 tx typeArgs v0+        Core.TermEither v0 -> typeOfEither cx1 tx typeArgs v0+        Core.TermLambda v0 -> typeOfLambda cx1 tx typeArgs v0+        Core.TermLet v0 -> typeOfLet cx1 tx typeArgs v0+        Core.TermList v0 -> typeOfList cx1 tx typeArgs v0+        Core.TermLiteral v0 -> typeOfLiteral cx1 tx typeArgs v0+        Core.TermMap v0 -> typeOfMap cx1 tx typeArgs v0+        Core.TermOptional v0 -> typeOfMaybe cx1 tx typeArgs v0+        Core.TermPair v0 -> typeOfPair cx1 tx typeArgs v0+        Core.TermProject v0 -> typeOfProjection cx1 tx typeArgs v0+        Core.TermRecord v0 -> typeOfRecord cx1 tx typeArgs v0+        Core.TermSet v0 -> typeOfSet cx1 tx typeArgs v0+        Core.TermTypeApplication v0 -> typeOfTypeApplication cx1 tx typeArgs v0+        Core.TermTypeLambda v0 -> typeOfTypeLambda cx1 tx typeArgs v0+        Core.TermInject v0 -> typeOfInjection cx1 tx typeArgs v0+        Core.TermUnit -> typeOfUnit cx1 tx typeArgs+        Core.TermUnwrap v0 -> typeOfUnwrap cx1 tx typeArgs v0+        Core.TermVariable v0 -> typeOfVariable cx1 tx typeArgs v0+        Core.TermWrap v0 -> typeOfWrappedTerm cx1 tx typeArgs v0+        _ -> Left (Errors.ErrorChecking (Checking.CheckingErrorUnsupportedTermVariant (Checking.UnsupportedTermVariantError {+          Checking.unsupportedTermVariantErrorTermVariant = (Reflect.termVariant term)})))+-- | Reconstruct the type of an annotated term (Either/InferenceContext version)+typeOfAnnotatedTerm :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.AnnotatedTerm -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfAnnotatedTerm cx tx typeArgs at = typeOf cx tx typeArgs (Core.annotatedTermBody at)+-- | Reconstruct the type of an application term (Either/InferenceContext version)+typeOfApplication :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Application -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfApplication cx tx typeArgs app =++      let fun = Core.applicationFunction app+          arg = Core.applicationArgument app+          tryType =+                  \cx0 -> \tfun -> \targ -> case tfun of+                    Core.TypeForall v0 -> tryType cx0 (Core.forallTypeBody v0) targ+                    Core.TypeFunction v0 ->+                      let dom = Core.functionTypeDomain v0+                          cod = Core.functionTypeCodomain v0+                      in (Logic.ifElse (typesEffectivelyEqual tx dom targ) (Right (cod, cx0)) (Left (Errors.ErrorChecking (Checking.CheckingErrorTypeMismatch (Checking.TypeMismatchError {+                        Checking.typeMismatchErrorExpectedType = dom,+                        Checking.typeMismatchErrorActualType = targ})))))+                    Core.TypeVariable _ ->+                      let nameResult = Names.freshName cx0+                          freshN = Pairs.first nameResult+                          cx1 = Pairs.second nameResult+                      in (Right (Core.TypeVariable freshN, cx1))+                    _ -> Left (Errors.ErrorChecking (Checking.CheckingErrorNotAFunctionType (Checking.NotAFunctionTypeError {+                      Checking.notAFunctionTypeErrorType = tfun})))+      in (Eithers.bind (typeOf cx tx [] fun) (\result1 ->+        let tfun = Pairs.first result1+            cx2 = Pairs.second result1+        in (Eithers.bind (typeOf cx2 tx [] arg) (\result2 ->+          let targ = Pairs.first result2+              cx3 = Pairs.second result2+          in (Eithers.bind (tryType cx3 tfun targ) (\result3 ->+            let t = Pairs.first result3+                cx4 = Pairs.second result3+            in (Eithers.bind (applyTypeArgumentsToType cx4 tx typeArgs t) (\applied -> Right (applied, cx4)))))))))+-- | Reconstruct the type of a case statement (Either/InferenceContext version)+typeOfCaseStatement :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.CaseStatement -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfCaseStatement cx tx typeArgs cs =++      let tname = Core.caseStatementTypeName cs+          dflt = Core.caseStatementDefault cs+          cases = Core.caseStatementCases cs+          cterms = Lists.map Core.caseAlternativeHandler cases+      in (Eithers.bind (Eithers.mapOptional (\e -> typeOf cx tx [] e) dflt) (\dfltResult ->+        let tdflt = Optionals.map Pairs.first dfltResult+            cx2 = Optionals.cases dfltResult cx Pairs.second+            foldResult =+                    Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR ->+                      let types = Pairs.first accR+                          cxA = Pairs.second accR+                      in (Eithers.bind (typeOf cxA tx [] term) (\tResult ->+                        let t = Pairs.first tResult+                            cxB = Pairs.second tResult+                        in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx2)) cterms+        in (Eithers.bind foldResult (\foldR ->+          let tcterms = Pairs.first foldR+              cx3 = Pairs.second foldR+              fcodsResult =+                      Lists.foldl (\acc -> \t -> Eithers.bind acc (\accR ->+                        let cods = Pairs.first accR+                        in (Eithers.bind (ExtractCore.functionType t) (\ft -> Right (Lists.concat2 cods (Lists.pure (Core.functionTypeCodomain ft)), cx3))))) (Right ([], cx3)) tcterms+          in (Eithers.bind fcodsResult (\fcodsR ->+            let fcods = Pairs.first fcodsR+                cods = Optionals.cat (Lists.cons tdflt (Lists.map Optionals.pure fcods))+            in (Eithers.bind (checkSameType cx3 tx "case branches" cods) (\cod -> Right (+              Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Resolution.nominalApplication tname typeArgs),+                Core.functionTypeCodomain = cod}),+              cx3)))))))))+-- | Reconstruct the type of an either value (Either/InferenceContext version)+typeOfEither :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Either Core.Term Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfEither cx tx typeArgs et =++      let n = Lists.length typeArgs+          arityErr =+                  Left (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError {+                    Checking.typeArityMismatchErrorType = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = Core.TypeUnit,+                      Core.eitherTypeRight = Core.TypeUnit})),+                    Checking.typeArityMismatchErrorExpectedArity = 2,+                    Checking.typeArityMismatchErrorActualArity = n,+                    Checking.typeArityMismatchErrorTypeArguments = typeArgs})))+      in (Optionals.cases (Lists.uncons typeArgs) arityErr (\uc0 ->+        let ta0 = Pairs.first uc0+        in (Optionals.cases (Lists.uncons (Pairs.second uc0)) arityErr (\uc1 ->+          let ta1 = Pairs.first uc1+          in (Logic.ifElse (Equality.equal n 2) (Eithers.either (\leftTerm -> Eithers.bind (typeOf cx tx [] leftTerm) (\result ->+            let leftType = Pairs.first result+                cx2 = Pairs.second result+            in (Right (+              Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = leftType,+                Core.eitherTypeRight = ta1}),+              cx2)))) (\rightTerm -> Eithers.bind (typeOf cx tx [] rightTerm) (\result ->+            let rightType = Pairs.first result+                cx2 = Pairs.second result+            in (Right (+              Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = ta0,+                Core.eitherTypeRight = rightType}),+              cx2)))) et) arityErr)))))+-- | Reconstruct the type of a union injection (Either/InferenceContext version)+typeOfInjection :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Injection -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfInjection cx tx typeArgs injection =++      let tname = Core.injectionTypeName injection+          field = Core.injectionField injection+          fname = Core.fieldName field+          fterm = Core.fieldTerm field+      in (Eithers.bind (Resolution.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\schemaResult ->+        let schemaType = Pairs.first schemaResult+            cx2 = Pairs.second schemaResult+            svars = Core.typeSchemeVariables schemaType+            sbody = Core.typeSchemeBody schemaType+        in (Eithers.bind (ExtractCore.unionType tname sbody) (\sfields -> Eithers.bind (Resolution.findFieldType cx2 fname sfields) (\ftyp -> Right (Resolution.nominalApplication tname typeArgs, cx2))))))+-- | Reconstruct the type of a lambda function (Either/InferenceContext version)+typeOfLambda :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Lambda -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfLambda cx tx typeArgs l =++      let v = Core.lambdaParameter l+          mdom = Core.lambdaDomain l+          body = Core.lambdaBody l+      in (Eithers.bind (Optionals.cases mdom (Left (Errors.ErrorChecking (Checking.CheckingErrorUntypedLambda (Checking.UntypedLambdaError {+      })))) (\dom ->+        let types2 = Maps.insert v (Scoping.fTypeToTypeScheme dom) (Graph.graphBoundTypes tx)+        in (Eithers.bind (typeOf cx (Graph.Graph {+          Graph.graphBoundTerms = (Graph.graphBoundTerms tx),+          Graph.graphBoundTypes = types2,+          Graph.graphClassConstraints = (Graph.graphClassConstraints tx),+          Graph.graphLambdaVariables = (Graph.graphLambdaVariables tx),+          Graph.graphMetadata = (Graph.graphMetadata tx),+          Graph.graphPrimitives = (Graph.graphPrimitives tx),+          Graph.graphSchemaTypes = (Graph.graphSchemaTypes tx),+          Graph.graphTypeVariables = (Graph.graphTypeVariables tx)}) [] body) (\codResult ->+          let cod = Pairs.first codResult+              cx2 = Pairs.second codResult+          in (Right (+            Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = dom,+              Core.functionTypeCodomain = cod}),+            cx2)))))) (\tbodyResult ->+        let tbody = Pairs.first tbodyResult+            cx3 = Pairs.second tbodyResult+        in (Eithers.bind (applyTypeArgumentsToType cx3 tx typeArgs tbody) (\applied -> Right (applied, cx3)))))+-- | Reconstruct the type of a let binding (Either/InferenceContext version)+typeOfLet :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Let -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfLet cx tx typeArgs letTerm =++      let bs = Core.letBindings letTerm+          body = Core.letBody letTerm+          bnames = Lists.map Core.bindingName bs+          bindingType =+                  \b -> Optionals.cases (Core.bindingTypeScheme b) (Left (Errors.ErrorChecking (Checking.CheckingErrorUntypedLetBinding (Checking.UntypedLetBindingError {+                    Checking.untypedLetBindingErrorBinding = b})))) (\ts -> Right (Scoping.typeSchemeToFType ts))+          btypesResult =+                  Lists.foldl (\acc -> \b -> Eithers.bind acc (\accR ->+                    let types = Pairs.first accR+                    in (Eithers.bind (bindingType b) (\btype -> Right (Lists.concat2 types (Lists.pure btype), ()))))) (Right ([], ())) bs+      in (Eithers.bind btypesResult (\btypesR ->+        let btypes = Pairs.first btypesR+            tx2 =+                    Graph.Graph {+                      Graph.graphBoundTerms = (Graph.graphBoundTerms tx),+                      Graph.graphBoundTypes = (Maps.union (Maps.fromList (Lists.zip bnames (Lists.map Scoping.fTypeToTypeScheme btypes))) (Graph.graphBoundTypes tx)),+                      Graph.graphClassConstraints = (Graph.graphClassConstraints tx),+                      Graph.graphLambdaVariables = (Graph.graphLambdaVariables tx),+                      Graph.graphMetadata = (Graph.graphMetadata tx),+                      Graph.graphPrimitives = (Graph.graphPrimitives tx),+                      Graph.graphSchemaTypes = (Graph.graphSchemaTypes tx),+                      Graph.graphTypeVariables = (Graph.graphTypeVariables tx)}+        in (Eithers.bind (typeOf cx tx2 [] body) (\tResult ->+          let t = Pairs.first tResult+              cx2 = Pairs.second tResult+          in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2)))))))+-- | Reconstruct the type of a list (Either/InferenceContext version)+typeOfList :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> [Core.Term] -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfList cx tx typeArgs els =++      let listArityErr =+              Left (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError {+                Checking.typeArityMismatchErrorType = (Core.TypeList Core.TypeUnit),+                Checking.typeArityMismatchErrorExpectedArity = 1,+                Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs),+                Checking.typeArityMismatchErrorTypeArguments = typeArgs})))+      in (Logic.ifElse (Lists.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Optionals.cases (Lists.maybeHead typeArgs) listArityErr (\ta0 -> Right (Core.TypeList ta0, cx))) listArityErr) (+        let foldResult =+                Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR ->+                  let types = Pairs.first accR+                      cxA = Pairs.second accR+                  in (Eithers.bind (typeOf cxA tx [] term) (\tResult ->+                    let t = Pairs.first tResult+                        cxB = Pairs.second tResult+                    in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) els+        in (Eithers.bind foldResult (\foldR ->+          let eltypes = Pairs.first foldR+              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 cx tx typeArgs lit =++      let t = Core.TypeLiteral (Reflect.literalType lit)+      in (Eithers.bind (applyTypeArgumentsToType cx tx typeArgs t) (\applied -> Right (applied, cx)))+-- | Reconstruct the type of a map (Either/InferenceContext version)+typeOfMap :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> M.Map Core.Term Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfMap cx tx typeArgs m =++      let mapArityErr =+              Left (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError {+                Checking.typeArityMismatchErrorType = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = Core.TypeUnit,+                  Core.mapTypeValues = Core.TypeUnit})),+                Checking.typeArityMismatchErrorExpectedArity = 2,+                Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs),+                Checking.typeArityMismatchErrorTypeArguments = typeArgs})))+      in (Logic.ifElse (Maps.null m) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 2) (Optionals.cases (Lists.uncons typeArgs) mapArityErr (\uc0 ->+        let ta0 = Pairs.first uc0+        in (Optionals.cases (Lists.uncons (Pairs.second uc0)) mapArityErr (\uc1 ->+          let ta1 = Pairs.first uc1+          in (Right (+            Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = ta0,+              Core.mapTypeValues = ta1}),+            cx)))))) mapArityErr) (+        let pairs = Maps.toList m+            keyFoldResult =+                    Lists.foldl (\acc -> \p -> Eithers.bind acc (\accR ->+                      let types = Pairs.first accR+                          cxA = Pairs.second accR+                      in (Eithers.bind (typeOf cxA tx [] (Pairs.first p)) (\tResult ->+                        let t = Pairs.first tResult+                            cxB = Pairs.second tResult+                        in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) pairs+        in (Eithers.bind keyFoldResult (\keyFoldR ->+          let keyTypes = Pairs.first keyFoldR+              cx2 = Pairs.second keyFoldR+          in (Eithers.bind (checkSameType cx2 tx "map keys" keyTypes) (\kt ->+            let valFoldResult =+                    Lists.foldl (\acc -> \p -> Eithers.bind acc (\accR ->+                      let types = Pairs.first accR+                          cxA = Pairs.second accR+                      in (Eithers.bind (typeOf cxA tx [] (Pairs.second p)) (\tResult ->+                        let t = Pairs.first tResult+                            cxB = Pairs.second tResult+                        in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx2)) pairs+            in (Eithers.bind valFoldResult (\valFoldR ->+              let valTypes = Pairs.first valFoldR+                  cx3 = Pairs.second valFoldR+              in (Eithers.bind (checkSameType cx3 tx "map values" valTypes) (\vt -> Eithers.bind (applyTypeArgumentsToType cx3 tx typeArgs (Core.TypeMap (Core.MapType {+                Core.mapTypeKeys = kt,+                Core.mapTypeValues = vt}))) (\applied -> Right (applied, cx3))))))))))))+-- | Reconstruct the type of an optional value (Either/InferenceContext version)+typeOfMaybe :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Maybe Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfMaybe cx tx typeArgs mt =++      let forNothing =++                let n = Lists.length typeArgs+                    maybeArityErr =+                            Left (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError {+                              Checking.typeArityMismatchErrorType = (Core.TypeOptional Core.TypeUnit),+                              Checking.typeArityMismatchErrorExpectedArity = 1,+                              Checking.typeArityMismatchErrorActualArity = n,+                              Checking.typeArityMismatchErrorTypeArguments = typeArgs})))+                in (Logic.ifElse (Equality.equal n 1) (Optionals.cases (Lists.maybeHead typeArgs) maybeArityErr (\ta0 -> Right (Core.TypeOptional ta0, cx))) maybeArityErr)+          forJust =+                  \term -> Eithers.bind (typeOf cx tx [] term) (\tResult ->+                    let termType = Pairs.first tResult+                        cx2 = Pairs.second tResult+                        t = Core.TypeOptional termType+                    in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2))))+      in (Optionals.cases mt forNothing forJust)+-- | Reconstruct the type of a pair (Either/InferenceContext version)+typeOfPair :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> (Core.Term, Core.Term) -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfPair cx tx typeArgs p =++      let n = Lists.length typeArgs+      in (Logic.ifElse (Equality.equal n 2) (+        let pairFst = Pairs.first p+            pairSnd = Pairs.second p+        in (Eithers.bind (typeOf cx tx [] pairFst) (\result1 ->+          let firstType = Pairs.first result1+              cx2 = Pairs.second result1+          in (Eithers.bind (typeOf cx2 tx [] pairSnd) (\result2 ->+            let secondType = Pairs.first result2+                cx3 = Pairs.second result2+            in (Right (+              Core.TypePair (Core.PairType {+                Core.pairTypeFirst = firstType,+                Core.pairTypeSecond = secondType}),+              cx3))))))) (Left (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError {+        Checking.typeArityMismatchErrorType = (Core.TypePair (Core.PairType {+          Core.pairTypeFirst = Core.TypeUnit,+          Core.pairTypeSecond = Core.TypeUnit})),+        Checking.typeArityMismatchErrorExpectedArity = 2,+        Checking.typeArityMismatchErrorActualArity = n,+        Checking.typeArityMismatchErrorTypeArguments = typeArgs})))))+-- | Reconstruct the type of a primitive function (Either/InferenceContext version)+typeOfPrimitive :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Name -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfPrimitive cx tx typeArgs name =++      let rawTs =+              Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives tx))+      in (Optionals.cases rawTs (Left (Errors.ErrorUndefinedTermVariable (ErrorCore.UndefinedTermVariableError {+        ErrorCore.undefinedTermVariableErrorLocation = (Paths.SubtermPath []),+        ErrorCore.undefinedTermVariableErrorName = name}))) (\tsRaw ->+        let instResult = Resolution.instantiateTypeScheme cx tsRaw+            ts = Pairs.first instResult+            cx2 = Pairs.second instResult+            t = Scoping.typeSchemeToFType ts+        in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2)))))+-- | Reconstruct the type of a record projection (Either/InferenceContext version)+typeOfProjection :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Projection -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfProjection cx tx typeArgs p =++      let tname = Core.projectionTypeName p+          fname = Core.projectionFieldName p+      in (Eithers.bind (Resolution.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\schemaResult ->+        let schemaType = Pairs.first schemaResult+            cx2 = Pairs.second schemaResult+            svars = Core.typeSchemeVariables schemaType+            sbody = Core.typeSchemeBody schemaType+        in (Eithers.bind (ExtractCore.recordType tname sbody) (\sfields -> Eithers.bind (Resolution.findFieldType cx2 fname sfields) (\ftyp ->+          let subst = Typing.TypeSubst (Maps.fromList (Lists.zip svars typeArgs))+              sftyp = Substitution.substInType subst ftyp+          in (Right (+            Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Resolution.nominalApplication tname typeArgs),+              Core.functionTypeCodomain = sftyp}),+            cx2)))))))+-- | Reconstruct the type of a record (Either/InferenceContext version)+typeOfRecord :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Record -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfRecord cx tx typeArgs record =++      let tname = Core.recordTypeName record+          fields = Core.recordFields record+          foldResult =+                  Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR ->+                    let types = Pairs.first accR+                        cxA = Pairs.second accR+                    in (Eithers.bind (typeOf cxA tx [] term) (\tResult ->+                      let t = Pairs.first tResult+                          cxB = Pairs.second tResult+                      in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) (Lists.map Core.fieldTerm fields)+      in (Eithers.bind foldResult (\foldR ->+        let cx2 = Pairs.second foldR+        in (Right (Resolution.nominalApplication tname typeArgs, cx2))))+-- | Reconstruct the type of a set (Either/InferenceContext version)+typeOfSet :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> S.Set Core.Term -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfSet cx tx typeArgs els =++      let setArityErr =+              Left (Errors.ErrorChecking (Checking.CheckingErrorTypeArityMismatch (Checking.TypeArityMismatchError {+                Checking.typeArityMismatchErrorType = (Core.TypeSet Core.TypeUnit),+                Checking.typeArityMismatchErrorExpectedArity = 1,+                Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs),+                Checking.typeArityMismatchErrorTypeArguments = typeArgs})))+      in (Logic.ifElse (Sets.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Optionals.cases (Lists.maybeHead typeArgs) setArityErr (\ta0 -> Right (Core.TypeSet ta0, cx))) setArityErr) (+        let foldResult =+                Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR ->+                  let types = Pairs.first accR+                      cxA = Pairs.second accR+                  in (Eithers.bind (typeOf cxA tx [] term) (\tResult ->+                    let t = Pairs.first tResult+                        cxB = Pairs.second tResult+                    in (Right (Lists.concat2 types (Lists.pure t), cxB)))))) (Right ([], cx)) (Sets.toList els)+        in (Eithers.bind foldResult (\foldR ->+          let eltypes = Pairs.first foldR+              cx2 = Pairs.second foldR+          in (Eithers.bind (checkSameType cx2 tx "set elements" eltypes) (\unifiedType -> Right (Core.TypeSet unifiedType, cx2)))))))+-- | Check the type of a term+typeOfTerm :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Type+typeOfTerm cx g term = Eithers.map Pairs.first (typeOf cx g [] term)+-- | Reconstruct the type of a type application term (Either/InferenceContext version)+typeOfTypeApplication :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.TypeApplicationTerm -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfTypeApplication cx tx typeArgs tyapp =++      let body = Core.typeApplicationTermBody tyapp+          t = Core.typeApplicationTermType tyapp+      in (typeOf cx tx (Lists.cons t typeArgs) body)+-- | Reconstruct the type of a type lambda (type abstraction) term (Either/InferenceContext version)+typeOfTypeLambda :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.TypeLambda -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfTypeLambda cx tx typeArgs tl =++      let v = Core.typeLambdaParameter tl+          body = Core.typeLambdaBody tl+          vars = Graph.graphTypeVariables tx+          tx2 =+                  Graph.Graph {+                    Graph.graphBoundTerms = (Graph.graphBoundTerms tx),+                    Graph.graphBoundTypes = (Graph.graphBoundTypes tx),+                    Graph.graphClassConstraints = (Graph.graphClassConstraints tx),+                    Graph.graphLambdaVariables = (Graph.graphLambdaVariables tx),+                    Graph.graphMetadata = (Graph.graphMetadata tx),+                    Graph.graphPrimitives = (Graph.graphPrimitives tx),+                    Graph.graphSchemaTypes = (Graph.graphSchemaTypes tx),+                    Graph.graphTypeVariables = (Sets.insert v vars)}+      in (Eithers.bind (typeOf cx tx2 [] body) (\result1 ->+        let t1 = Pairs.first result1+            cx2 = Pairs.second result1+        in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs (Core.TypeForall (Core.ForallType {+          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 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)+typeOfUnwrap :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Name -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfUnwrap cx tx typeArgs tname =+    Eithers.bind (Resolution.requireSchemaType cx (Graph.graphSchemaTypes tx) tname) (\schemaResult ->+      let schemaType = Pairs.first schemaResult+          cx2 = Pairs.second schemaResult+          svars = Core.typeSchemeVariables schemaType+          sbody = Core.typeSchemeBody schemaType+      in (Eithers.bind (ExtractCore.wrappedType tname sbody) (\wrapped ->+        let subst = Typing.TypeSubst (Maps.fromList (Lists.zip svars typeArgs))+            swrapped = Substitution.substInType subst wrapped+        in (Right (+          Core.TypeFunction (Core.FunctionType {+            Core.functionTypeDomain = (Resolution.nominalApplication tname typeArgs),+            Core.functionTypeCodomain = swrapped}),+          cx2)))))+-- | Reconstruct the type of a variable (Either/InferenceContext version)+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 {+        ErrorCore.untypedTermVariableErrorLocation = (Paths.SubtermPath []),+        ErrorCore.untypedTermVariableErrorName = name}))) forScheme) forScheme)+-- | Reconstruct the type of a wrapped term (Either/InferenceContext version)+typeOfWrappedTerm :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.WrappedTerm -> Either Errors.Error (Core.Type, Typing.InferenceContext)+typeOfWrappedTerm cx tx typeArgs wt =++      let tname = Core.wrappedTermTypeName wt+          body = Core.wrappedTermBody wt+      in (Eithers.bind (typeOf cx tx [] body) (\result ->+        let cx2 = Pairs.second result+        in (Right (Resolution.nominalApplication tname typeArgs, cx2))))+-- | Check whether a list of types are effectively equal, disregarding type aliases and free type variable naming. Also treats free type variables (not in schema) as wildcards, since inference has already verified consistency.+typesAllEffectivelyEqual :: Graph.Graph -> [Core.Type] -> Bool+typesAllEffectivelyEqual tx tlist =++      let types = Graph.graphSchemaTypes tx+          containsFreeVar =+                  \t ->+                    let allVars = Variables.freeVariablesInTypeSimple t+                        schemaNames = Sets.fromList (Maps.keys types)+                    in (Logic.not (Sets.null (Sets.difference allVars schemaNames)))+          anyContainsFreeVar = Lists.foldl (\acc -> \t -> Logic.or acc (containsFreeVar t)) False tlist+      in (Logic.ifElse anyContainsFreeVar True (Logic.ifElse (allEqual (Lists.map (\t -> normalizeTypeFreeVars t) tlist)) True (allEqual (Lists.map (\t -> normalizeTypeFreeVars (Strip.deannotateTypeRecursive (Dependencies.replaceTypedefs types t))) tlist))))+-- | Check whether two types are effectively equal, disregarding type aliases, forall quantifiers, and treating in-scope type variables as wildcards+typesEffectivelyEqual :: Graph.Graph -> Core.Type -> Core.Type -> Bool+typesEffectivelyEqual tx t1 t2 =+    Logic.or (containsInScopeTypeVars tx t1) (Logic.or (containsInScopeTypeVars tx t2) (typesAllEffectivelyEqual tx [+      Resolution.fullyStripAndNormalizeType t1,+      (Resolution.fullyStripAndNormalizeType t2)]))
+ src/main/haskell/Hydra/Classes.hs view
@@ -0,0 +1,37 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Registry of Hydra's built-in type classes.++module Hydra.Classes where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | The equality type class: instances support structural equality.+equality :: Typing.TypeClass+equality = Typing.TypeClass {+  Typing.typeClassDescription = "Equality: instances support structural equality."}+-- | The ordering type class: instances support total ordering (and equality).+ordering :: Typing.TypeClass+ordering =+    Typing.TypeClass {+      Typing.typeClassDescription = "Ordering: instances support total ordering (and equality)."}
+ src/main/haskell/Hydra/Codegen.hs view
@@ -0,0 +1,523 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Pure code generation pipeline for bootstrapping Hydra across languages.++module Hydra.Codegen where+import qualified Hydra.Adapt as Adapt+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Packaging as DecodePackaging+import qualified Hydra.Decoding as Decoding+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Packaging as EncodePackaging+import qualified Hydra.Encoding as Encoding+import qualified Hydra.Environment as Environment+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Inference as Inference+import qualified Hydra.Json.Decode as Decode+import qualified Hydra.Json.Encode as Encode+import qualified Hydra.Json.Model as Model+import qualified Hydra.Json.Writer as Writer+import qualified Hydra.Lexical as Lexical+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.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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Build a schema map (Name -> Type) from a graph's schema types+buildSchemaMap :: Graph.Graph -> M.Map Core.Name Core.Type+buildSchemaMap g = Maps.map (\ts -> Strip.deannotateType (Core.typeSchemeBody ts)) (Graph.graphSchemaTypes g)+-- | Decode a single module from a JSON value+decodeModuleFromJson :: Graph.Graph -> [Packaging.Module] -> Model.Value -> Either Errors.Error Packaging.Module+decodeModuleFromJson bsGraph universeModules jsonVal =++      let graph = modulesToGraph bsGraph universeModules universeModules+          schemaMap = buildSchemaMap graph+          modType = Core.TypeVariable (Core.Name "hydra.packaging.Module")+      in (Eithers.either (\err -> Left (Errors.ErrorOther (Errors.OtherError err))) (\term -> Eithers.either (\decErr -> Left (Errors.ErrorDecoding decErr)) (\mod -> Right mod) (DecodePackaging.module_ graph term)) (Decode.fromJson schemaMap (Core.Name "hydra.packaging.Module") modType jsonVal))+-- | Escape unescaped control characters inside JSON string literals+escapeControlCharsInJson :: [Int] -> [Int]+escapeControlCharsInJson input =++      let hexDigit = \n -> Logic.ifElse (Equality.lt n 10) (Math.add 48 n) (Math.add 97 (Math.sub n 10))+          escapeToUnicode =+                  \b -> [+                    92,+                    117,+                    48,+                    48,+                    (hexDigit (Optionals.fromOptional 0 (Math.maybeDiv b 16))),+                    (hexDigit (Optionals.fromOptional 0 (Math.maybeMod b 16)))]+          go =+                  \inStr -> \esc -> \bytes -> Optionals.cases (Lists.uncons bytes) [] (\uc ->+                    let b = Pairs.first uc+                        bs = Pairs.second uc+                    in (Logic.ifElse esc (Lists.cons b (go inStr False bs)) (Logic.ifElse (Logic.and (Equality.equal b 92) inStr) (Lists.cons b (go inStr True bs)) (Logic.ifElse (Equality.equal b 34) (Lists.cons b (go (Logic.not inStr) False bs)) (Logic.ifElse (Logic.and inStr (Equality.lt b 32)) (Lists.concat2 (escapeToUnicode b) (go inStr False bs)) (Lists.cons b (go inStr False bs)))))))+      in (go False False input)+-- | Format a primitive for the lexicon+formatPrimitive :: Graph.Primitive -> String+formatPrimitive prim =++      let name = Core.unName (Packaging.primitiveDefinitionName (Graph.primitiveDefinition prim))+          typ = Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim))+          typeStr = ShowCore.typeScheme typ+      in (Strings.cat2 (Strings.cat2 (Strings.cat2 "  " name) " : ") typeStr)+-- | Format a term binding for the lexicon+formatTermBinding :: Core.Binding -> String+formatTermBinding binding =++      let name = Core.unName (Core.bindingName binding)+          typeStr = Optionals.cases (Core.bindingTypeScheme binding) "?" (\scheme -> ShowCore.typeScheme scheme)+      in (Strings.cat2 (Strings.cat2 (Strings.cat2 "  " name) " : ") typeStr)+-- | Format a type binding for the lexicon+formatTypeBinding :: Graph.Graph -> Core.Binding -> Either Errors.Error String+formatTypeBinding graph binding =+    Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\_a -> _a) (DecodeCore.type_ graph (Core.bindingTerm binding))) (\typ -> Right (Strings.cat2 (Strings.cat2 (Strings.cat2 "  " (Core.unName (Core.bindingName binding))) " = ") (ShowCore.type_ typ)))+-- | Generate encoder or decoder modules for a list of type modules+generateCoderModules :: (t0 -> Graph.Graph -> t1 -> Either t2 (Maybe t3)) -> Graph.Graph -> [Packaging.Module] -> [t1] -> t0 -> Either t2 [t3]+generateCoderModules codec bsGraph universeModules typeModules cx =++      let universe = Maps.fromList (Lists.map (\m -> (Packaging.moduleName m, m)) (Lists.concat2 universeModules universeModules))+          closureModules = moduleDepsTransitive universe universeModules+          schemaElements =+                  Lists.concat (Lists.map (\m -> 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 m))) closureModules)+          dataElements =+                  Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                      Core.bindingName = (Packaging.termDefinitionName v0),+                      Core.bindingTerm = (Packaging.termDefinitionBody v0),+                      Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                    _ -> Nothing) (Packaging.moduleDefinitions m))) closureModules)+          schemaGraph = Lexical.elementsToGraph bsGraph Maps.empty schemaElements+          schemaTypes = Eithers.either (\_ -> Maps.empty) (\_r -> _r) (Environment.schemaGraphToTypingEnvironment schemaGraph)+          allElements = Lists.concat2 schemaElements dataElements+          graph = Lexical.elementsToGraph bsGraph schemaTypes allElements+      in (Eithers.map (\results -> Optionals.cat results) (Eithers.mapList (\m -> codec cx graph m) typeModules))+-- | Generate the lexicon content from a graph+generateLexicon :: Graph.Graph -> Either Errors.Error String+generateLexicon graph =++      let bindings = Lexical.graphToBindings graph+          primitives = Maps.elems (Graph.graphPrimitives graph)+          partitioned = Lists.partition (\b -> Annotations.isNativeType b) bindings+          typeBindings = Pairs.first partitioned+          termBindings = Pairs.second partitioned+          sortedPrimitives = Lists.sortOn (\p -> Packaging.primitiveDefinitionName (Graph.primitiveDefinition p)) primitives+          sortedTypes = Lists.sortOn (\b -> Core.bindingName b) typeBindings+          sortedTerms = Lists.sortOn (\b -> Core.bindingName b) termBindings+      in (Eithers.bind (Eithers.mapList (\b -> formatTypeBinding graph b) sortedTypes) (\typeLines ->+        let termLines = Lists.map (\b -> formatTermBinding b) sortedTerms+            primitiveLines = Lists.map (\p -> formatPrimitive p) sortedPrimitives+        in (Right (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "Primitives:\n" (Strings.unlines primitiveLines)) "\nTypes:\n") (Strings.unlines typeLines)) "\nTerms:\n") (Strings.unlines termLines)))))+-- | Pure core of code generation: given a coder, language, infer flag, bootstrap graph, universe, and modules to generate, produce a list of (filePath, content) pairs. Emission flags doExpand/doHoistCaseStatements/doHoistPolymorphicLetBindings are derived from the absence of the matching LanguageFeature in lang.supportedFeatures: a target that lacks partialApplication needs eta expansion (doExpand=true), and so on.+generateSourceFiles :: Ord t0 => ((Packaging.Module -> [Packaging.Definition] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (M.Map t0 t1)) -> Coders.Language -> Bool -> Graph.Graph -> [Packaging.Module] -> [Packaging.Module] -> Typing.InferenceContext -> Either Errors.Error [(t0, t1)])+generateSourceFiles printDefinitions lang doInfer bsGraph universeModules modsToGenerate cx =++      let namespaceMap = Maps.fromList (Lists.map (\m -> (Packaging.moduleName m, m)) (Lists.concat2 universeModules modsToGenerate))+          constraints = Coders.languageConstraints lang+          features = Coders.languageSupportedFeatures lang+          doExpand = Logic.not (Sets.member Coders.LanguageFeaturePartialApplication features)+          doHoistCaseStatements = Logic.not (Sets.member Coders.LanguageFeatureNestedCaseStatements features)+          doHoistPolymorphicLetBindings = Logic.not (Sets.member Coders.LanguageFeatureNestedPolymorphicLetBindings features)+          typeModulesToGenerate =+                  Lists.filter (\mod -> Logic.not (Lists.null (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))))) modsToGenerate+          termModulesToGenerate =+                  Lists.filter (\mod -> Logic.not (Lists.null (Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                      Core.bindingName = (Packaging.termDefinitionName v0),+                      Core.bindingTerm = (Packaging.termDefinitionBody v0),+                      Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                    _ -> Nothing) (Packaging.moduleDefinitions mod))))) modsToGenerate+          closureMods = moduleDepsTransitive namespaceMap modsToGenerate+          schemaElements =+                  Lists.concat (Lists.map (\m -> 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 m))) closureMods)+          dataElements =+                  Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                      Core.bindingName = (Packaging.termDefinitionName v0),+                      Core.bindingTerm = (Packaging.termDefinitionBody v0),+                      Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                    _ -> Nothing) (Packaging.moduleDefinitions m))) closureMods)+          schemaGraph = Lexical.elementsToGraph bsGraph Maps.empty schemaElements+          schemaTypes2 = Eithers.either (\_ -> Maps.empty) (\_r -> _r) (Environment.schemaGraphToTypingEnvironment schemaGraph)+          dataGraph = Lexical.elementsToGraph bsGraph schemaTypes2 dataElements+      in (Eithers.bind (Logic.ifElse (Lists.null typeModulesToGenerate) (Right []) (+        let nameLists =+                Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                  Packaging.DefinitionType v0 -> Just (Packaging.typeDefinitionName v0)+                  _ -> Nothing) (Packaging.moduleDefinitions m))) typeModulesToGenerate+        in (Eithers.bind (Adapt.schemaGraphToDefinitions constraints schemaGraph nameLists cx) (\schemaResult ->+          let defLists = Pairs.second schemaResult+              schemaGraphWithTypes =+                      Graph.Graph {+                        Graph.graphBoundTerms = (Graph.graphBoundTerms schemaGraph),+                        Graph.graphBoundTypes = (Graph.graphBoundTypes schemaGraph),+                        Graph.graphClassConstraints = (Graph.graphClassConstraints schemaGraph),+                        Graph.graphLambdaVariables = (Graph.graphLambdaVariables schemaGraph),+                        Graph.graphMetadata = (Graph.graphMetadata schemaGraph),+                        Graph.graphPrimitives = (Graph.graphPrimitives schemaGraph),+                        Graph.graphSchemaTypes = schemaTypes2,+                        Graph.graphTypeVariables = (Graph.graphTypeVariables schemaGraph)}+          in (Eithers.map (\xs -> Lists.concat xs) (Eithers.mapList (\p ->+            let mod = Pairs.first p+                defs = Pairs.second p+            in (Eithers.map (\m -> Maps.toList m) (printDefinitions mod (Lists.map (\d -> Packaging.DefinitionType d) defs) cx schemaGraphWithTypes))) (Lists.zip typeModulesToGenerate defLists))))))) (\schemaFiles -> Eithers.bind (Logic.ifElse (Lists.null termModulesToGenerate) (Right []) (+        let namespaces = Lists.map (\m -> Packaging.moduleName m) termModulesToGenerate+        in (Eithers.bind (Adapt.dataGraphToDefinitions constraints doInfer doExpand doHoistCaseStatements doHoistPolymorphicLetBindings dataElements dataGraph namespaces cx) (\dataResult ->+          let g1 = Pairs.first dataResult+              defLists = Pairs.second dataResult+              defName =+                      \d -> case d of+                        Packaging.DefinitionTerm v0 -> Packaging.termDefinitionName v0+                        Packaging.DefinitionType v0 -> Packaging.typeDefinitionName v0+                        Packaging.DefinitionPrimitive v0 -> Packaging.primitiveDefinitionName v0+              refreshModule =+                      \els -> \m -> Packaging.Module {+                        Packaging.moduleName = (Packaging.moduleName m),+                        Packaging.moduleMetadata = (Packaging.moduleMetadata m),+                        Packaging.moduleDependencies = (Packaging.moduleDependencies m),+                        Packaging.moduleDefinitions = (Optionals.cat (Lists.map (\d -> case d of+                          Packaging.DefinitionType v0 -> Just (Packaging.DefinitionType v0)+                          Packaging.DefinitionTerm v0 -> Optionals.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)})) (Lists.find (\b -> Equality.equal (Core.bindingName b) (Packaging.termDefinitionName v0)) els)+                          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))+              dedupedDefLists = Lists.map dedupDefs defLists+          in (Eithers.map (\xs -> Lists.concat xs) (Eithers.mapList (\p ->+            let mod = Pairs.first p+                defs = Pairs.second p+            in (Eithers.map (\m -> Maps.toList m) (printDefinitions mod (Lists.map (\d -> Packaging.DefinitionTerm d) defs) cx g1))) (Lists.zip refreshedMods dedupedDefLists))))))) (\termFiles -> Right (Lists.concat2 schemaFiles termFiles))))+-- | Perform type inference and generate the lexicon for a set of modules+inferAndGenerateLexicon :: Typing.InferenceContext -> Graph.Graph -> [Packaging.Module] -> Either Errors.Error String+inferAndGenerateLexicon cx bsGraph kernelModules =++      let g0 = modulesToGraph bsGraph kernelModules kernelModules+          dataElements =+                  Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                      Core.bindingName = (Packaging.termDefinitionName v0),+                      Core.bindingTerm = (Packaging.termDefinitionBody v0),+                      Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                    _ -> Nothing) (Packaging.moduleDefinitions m))) kernelModules)+      in (Eithers.bind (Inference.inferGraphTypes cx dataElements g0) (\inferResultWithCx ->+        let g1 = Pairs.first (Pairs.first inferResultWithCx)+        in (generateLexicon g1)))+-- | Perform type inference on modules and reconstruct with inferred types+inferModules :: Typing.InferenceContext -> Graph.Graph -> [Packaging.Module] -> [Packaging.Module] -> Either Errors.Error [Packaging.Module]+inferModules cx bsGraph universeMods targetMods =++      let g0 = modulesToGraph bsGraph universeMods universeMods+          dataElements =+                  Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                      Core.bindingName = (Packaging.termDefinitionName v0),+                      Core.bindingTerm = (Packaging.termDefinitionBody v0),+                      Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                    _ -> Nothing) (Packaging.moduleDefinitions m))) universeMods)+      in (Eithers.bind (Inference.inferGraphTypes cx dataElements g0) (\inferResultWithCx ->+        let inferResult = Pairs.first inferResultWithCx+            inferredElements = Pairs.second inferResult+        in (Right (Lists.map (refreshModule inferredElements) targetMods))))+-- | Infer types for target modules in the context of a typed universe+inferModulesGiven :: Typing.InferenceContext -> Graph.Graph -> [Packaging.Module] -> [Packaging.Module] -> Either Errors.Error [Packaging.Module]+inferModulesGiven cx bsGraph universeMods targetMods =++      let g0 = modulesToGraph bsGraph universeMods universeMods+          nsMap = Maps.fromList (Lists.map (\m -> (Packaging.moduleName m, m)) universeMods)+          closureMods = moduleDepsTransitive nsMap targetMods+          targetNamespaces = Sets.fromList (Lists.map Packaging.moduleName targetMods)+          termBindings =+                  Lists.concat (Lists.map (\m ->+                    let isTarget = Sets.member (Packaging.moduleName m) targetNamespaces+                        bs =+                                Optionals.cat (Lists.map (\d -> case d of+                                  Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                                    Core.bindingName = (Packaging.termDefinitionName v0),+                                    Core.bindingTerm = (Packaging.termDefinitionBody v0),+                                    Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                                  _ -> Nothing) (Packaging.moduleDefinitions m))+                    in (Logic.ifElse isTarget bs (Lists.filter (\b -> Optionals.isNone (Core.bindingTypeScheme b)) bs))) closureMods)+          primitiveBindings =+                  Lists.concat (Lists.map (\m ->+                    let isTarget = Sets.member (Packaging.moduleName m) targetNamespaces+                        bs =+                                Optionals.cat (Lists.map (\d -> case d of+                                  Packaging.DefinitionPrimitive v0 -> Optionals.map (\impl -> Core.Binding {+                                    Core.bindingName = (Packaging.primitiveDefinitionName v0),+                                    Core.bindingTerm = impl,+                                    Core.bindingTypeScheme = (Just (Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature v0)))}) (Packaging.primitiveDefinitionDefaultImplementation v0)+                                  _ -> Nothing) (Packaging.moduleDefinitions m))+                    in (Logic.ifElse isTarget bs [])) closureMods)+          bindingsToInfer = Lists.concat2 termBindings primitiveBindings+          untouchedTypedBindings =+                  Lists.concat (Lists.map (\m ->+                    let isTarget = Sets.member (Packaging.moduleName m) targetNamespaces+                        bs =+                                Optionals.cat (Lists.map (\d -> case d of+                                  Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                                    Core.bindingName = (Packaging.termDefinitionName v0),+                                    Core.bindingTerm = (Packaging.termDefinitionBody v0),+                                    Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                                  _ -> Nothing) (Packaging.moduleDefinitions m))+                    in (Logic.ifElse isTarget [] (Lists.filter (\b -> Optionals.isGiven (Core.bindingTypeScheme b)) bs))) closureMods)+      in (Eithers.bind (Inference.inferGraphTypes cx bindingsToInfer g0) (\inferResultWithCx ->+        let inferResult = Pairs.first inferResultWithCx+            newlyInferredBindings = Pairs.second inferResult+            allInferredBindings = Lists.concat2 newlyInferredBindings untouchedTypedBindings+        in (Right (Lists.map (refreshModule allInferredBindings) targetMods))))+-- | Lower Definition.primitive arms to Definition.term arms with term-encoded PrimitiveDefinition+lowerPrimitiveDefinitions :: Packaging.Module -> Packaging.Module+lowerPrimitiveDefinitions m =++      let pkgNs = Packaging.ModuleName "hydra.packaging"+          coreNs = Packaging.ModuleName "hydra.core"+          primDefSig =+                  Scoping.typeSchemeToTermSignature (Core.TypeScheme {+                    Core.typeSchemeVariables = [],+                    Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.packaging.PrimitiveDefinition")),+                    Core.typeSchemeConstraints = Nothing})+          origDefs = Packaging.moduleDefinitions m+          hasPrim =+                  Lists.foldl (\acc -> \d -> Logic.or acc (case d of+                    Packaging.DefinitionPrimitive _ -> True+                    _ -> False)) False origDefs+      in (Logic.ifElse (Logic.not hasPrim) m (+        let newDefs =+                Lists.map (\d -> case d of+                  Packaging.DefinitionPrimitive v0 -> Packaging.DefinitionTerm (Packaging.TermDefinition {+                    Packaging.termDefinitionName = (Packaging.primitiveDefinitionName v0),+                    Packaging.termDefinitionMetadata = Nothing,+                    Packaging.termDefinitionSignature = (Just primDefSig),+                    Packaging.termDefinitionBody = (EncodePackaging.primitiveDefinition v0)})+                  _ -> d) origDefs+            currentDeps = Packaging.moduleDependencies m+            filteredDeps =+                    Lists.filter (\dep -> Logic.and (Logic.not (Equality.equal (Packaging.moduleDependencyModule dep) pkgNs)) (Logic.not (Equality.equal (Packaging.moduleDependencyModule dep) coreNs))) currentDeps+            newDeps =+                    Lists.concat2 filteredDeps [+                      Packaging.ModuleDependency {+                        Packaging.moduleDependencyModule = pkgNs,+                        Packaging.moduleDependencyPackage = Nothing},+                      Packaging.ModuleDependency {+                        Packaging.moduleDependencyModule = coreNs,+                        Packaging.moduleDependencyPackage = Nothing}]+        in Packaging.Module {+          Packaging.moduleName = (Packaging.moduleName m),+          Packaging.moduleMetadata = (Packaging.moduleMetadata m),+          Packaging.moduleDependencies = newDeps,+          Packaging.moduleDefinitions = newDefs}))+-- | Compute transitive closure of dependencies for a set of modules+moduleDepsTransitive :: M.Map Packaging.ModuleName Packaging.Module -> [Packaging.Module] -> [Packaging.Module]+moduleDepsTransitive nsMap modules =++      let closure =+              Sets.union (transitiveDeps (\m -> Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies m)) nsMap modules) (Sets.fromList (Lists.map (\m -> Packaging.moduleName m) modules))+      in (Optionals.cat (Lists.map (\n -> Maps.lookup n nsMap) (Sets.toList closure)))+-- | Convert a module name to a file path (e.g., hydra.core -> hydra/core)+moduleNameToPath :: Packaging.ModuleName -> String+moduleNameToPath ns = Strings.intercalate "/" (Strings.splitOn "." (Packaging.unModuleName ns))+-- | Convert a Module to a JSON string+moduleToJson :: M.Map Core.Name Core.Type -> Packaging.Module -> Either Errors.Error String+moduleToJson schemaMap m =++      let term = EncodePackaging.module_ m+          modType = Core.TypeVariable (Core.Name "hydra.packaging.Module")+      in (Eithers.map (\json -> Writer.printJson json) (Eithers.bimap (\_e -> Errors.ErrorOther (Errors.OtherError _e)) (\_a -> _a) (Encode.toJson schemaMap (Core.Name "hydra.packaging.Module") modType term)))+-- | Convert a generated Module into a Source module+moduleToSourceModule :: Packaging.Module -> Packaging.Module+moduleToSourceModule m =++      let sourceNs =+              Packaging.ModuleName (Strings.cat2 "hydra.sources." (Strings.intercalate "." (Lists.drop 1 (Strings.splitOn "." (Packaging.unModuleName (Packaging.moduleName m))))))+          modTypeNs = Packaging.ModuleName "hydra.packaging"+          moduleDef =+                  Packaging.DefinitionTerm (Packaging.TermDefinition {+                    Packaging.termDefinitionName = (Core.Name (Strings.cat2 (Packaging.unModuleName sourceNs) ".module_")),+                    Packaging.termDefinitionMetadata = Nothing,+                    Packaging.termDefinitionSignature = (Just (Scoping.typeSchemeToTermSignature (Core.TypeScheme {+                      Core.typeSchemeVariables = [],+                      Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.packaging.Module")),+                      Core.typeSchemeConstraints = Nothing}))),+                    Packaging.termDefinitionBody = (EncodePackaging.module_ m)})+      in Packaging.Module {+        Packaging.moduleName = sourceNs,+        Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+          Packaging.entityMetadataDescription = (Just (Strings.cat2 "Source module for " (Packaging.unModuleName (Packaging.moduleName m)))),+          Packaging.entityMetadataComments = [],+          Packaging.entityMetadataSeeAlso = [],+          Packaging.entityMetadataLifecycle = Nothing})),+        Packaging.moduleDependencies = [+          Packaging.ModuleDependency {+            Packaging.moduleDependencyModule = modTypeNs,+            Packaging.moduleDependencyPackage = Nothing}],+        Packaging.moduleDefinitions = [+          moduleDef]}+-- | Build a graph from universe modules and working modules, using an explicit bootstrap graph+modulesToGraph :: Graph.Graph -> [Packaging.Module] -> [Packaging.Module] -> Graph.Graph+modulesToGraph bsGraph universeModules modules =++      let universe = Maps.fromList (Lists.map (\m -> (Packaging.moduleName m, m)) (Lists.concat2 universeModules modules))+          closureModules = moduleDepsTransitive universe modules+          schemaElements =+                  Lists.concat (Lists.map (\m -> 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 m))) closureModules)+          dataElements =+                  Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                      Core.bindingName = (Packaging.termDefinitionName v0),+                      Core.bindingTerm = (Packaging.termDefinitionBody v0),+                      Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                    _ -> Nothing) (Packaging.moduleDefinitions m))) closureModules)+          schemaGraph = Lexical.elementsToGraph bsGraph Maps.empty schemaElements+          schemaTypes = Eithers.either (\_ -> Maps.empty) (\_r -> _r) (Environment.schemaGraphToTypingEnvironment schemaGraph)+          baseGraph = Lexical.elementsToGraph bsGraph schemaTypes dataElements+          universeDataElements =+                  Lists.concat (Lists.map (\m -> Optionals.cat (Lists.map (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Just (Core.Binding {+                      Core.bindingName = (Packaging.termDefinitionName v0),+                      Core.bindingTerm = (Packaging.termDefinitionBody v0),+                      Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+                    _ -> Nothing) (Packaging.moduleDefinitions m))) universeModules)+          universeBoundTypes =+                  Maps.fromList (Optionals.cat (Lists.map (\b -> Optionals.map (\ts -> (Core.bindingName b, ts)) (Core.bindingTypeScheme b)) universeDataElements))+      in Graph.Graph {+        Graph.graphBoundTerms = (Graph.graphBoundTerms baseGraph),+        Graph.graphBoundTypes = universeBoundTypes,+        Graph.graphClassConstraints = (Graph.graphClassConstraints baseGraph),+        Graph.graphLambdaVariables = (Graph.graphLambdaVariables baseGraph),+        Graph.graphMetadata = (Graph.graphMetadata baseGraph),+        Graph.graphPrimitives = (Graph.graphPrimitives baseGraph),+        Graph.graphSchemaTypes = (Graph.graphSchemaTypes baseGraph),+        Graph.graphTypeVariables = (Graph.graphTypeVariables baseGraph)}+-- | Rebuild a module's term definitions using freshly inferred bindings+refreshModule :: [Core.Binding] -> Packaging.Module -> Packaging.Module+refreshModule inferredElements m =+    Logic.ifElse (Logic.not (Logic.not (Lists.null (Optionals.cat (Lists.map (\d -> case d of+      Packaging.DefinitionTerm v0 -> Just (Core.Binding {+        Core.bindingName = (Packaging.termDefinitionName v0),+        Core.bindingTerm = (Packaging.termDefinitionBody v0),+        Core.bindingTypeScheme = (Optionals.map Scoping.termSignatureToTypeScheme (Packaging.termDefinitionSignature v0))})+      _ -> Nothing) (Packaging.moduleDefinitions m)))))) m (Packaging.Module {+      Packaging.moduleName = (Packaging.moduleName m),+      Packaging.moduleMetadata = (Packaging.moduleMetadata m),+      Packaging.moduleDependencies = (Packaging.moduleDependencies m),+      Packaging.moduleDefinitions = (Optionals.cat (Lists.map (\d -> case d of+        Packaging.DefinitionType v0 -> Just (Packaging.DefinitionType v0)+        Packaging.DefinitionTerm v0 -> Optionals.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)})) (Lists.find (\b -> Equality.equal (Core.bindingName b) (Packaging.termDefinitionName v0)) inferredElements)+        Packaging.DefinitionPrimitive v0 -> Just (Packaging.DefinitionPrimitive v0)) (Packaging.moduleDefinitions m)))})+-- | Compute transitive closure of module dependencies+transitiveDeps :: (Packaging.Module -> [Packaging.ModuleName]) -> M.Map Packaging.ModuleName Packaging.Module -> [Packaging.Module] -> S.Set Packaging.ModuleName+transitiveDeps getDeps nsMap startMods =++      let initialDeps =+              Sets.fromList (Lists.concat (Lists.map (\m -> Lists.filter (\dep -> Logic.not (Equality.equal dep (Packaging.moduleName m))) (getDeps m)) startMods))+          go =+                  \pending -> \visited -> Logic.ifElse (Sets.null pending) visited (+                    let newVisited = Sets.union visited pending+                        nextDeps =+                                Sets.fromList (Lists.concat (Lists.map (\nsv -> Optionals.cases (Maps.lookup nsv nsMap) [] (\depMod -> getDeps depMod)) (Sets.toList pending)))+                        newPending = Sets.difference nextDeps newVisited+                    in (go newPending newVisited))+      in (go initialDeps Sets.empty)
+ src/main/haskell/Hydra/Coders.hs view
@@ -0,0 +1,182 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Abstractions for paired transformations between languages++module Hydra.Coders where+import qualified Hydra.Core as Core+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | A two-level bidirectional encoder which adapts types to types and terms to terms+data Adapter t1 t2 v1 v2 =+  Adapter {+    -- | Whether information may be lost in the course of this adaptation+    adapterIsLossy :: Bool,+    -- | The source type+    adapterSource :: t1,+    -- | The target type+    adapterTarget :: t2,+    -- | The coder for transforming instances of the source type to instances of the target type+    adapterCoder :: (Coder v1 v2)}+_Adapter = Core.Name "hydra.coders.Adapter"+_Adapter_isLossy = Core.Name "isLossy"+_Adapter_source = Core.Name "source"+_Adapter_target = Core.Name "target"+_Adapter_coder = Core.Name "coder"+-- | An evaluation context together with a source language and a target language+data AdapterContext =+  AdapterContext {+    -- | The underlying graph of elements and primitives+    adapterContextGraph :: Graph.Graph,+    -- | The language being encoded or decoded+    adapterContextLanguage :: Language,+    -- | A map of type names to adapters for those types+    adapterContextAdapters :: (M.Map Core.Name (Adapter Core.Type Core.Type Core.Term Core.Term))}+_AdapterContext = Core.Name "hydra.coders.AdapterContext"+_AdapterContext_graph = Core.Name "graph"+_AdapterContext_language = Core.Name "language"+_AdapterContext_adapters = Core.Name "adapters"+-- | A two-level encoder and decoder, operating both at a type level and an instance (data) level+data Bicoder t1 t2 v1 v2 =+  Bicoder {+    -- | A function from source types to adapters+    bicoderEncode :: (t1 -> Adapter t1 t2 v1 v2),+    -- | A function from target types to adapters+    bicoderDecode :: (t2 -> Adapter t2 t1 v2 v1)}+_Bicoder = Core.Name "hydra.coders.Bicoder"+_Bicoder_encode = Core.Name "encode"+_Bicoder_decode = Core.Name "decode"+-- | Per-target case conventions for name forms that vary across emission targets+data CaseConventions =+  CaseConventions {+    -- | Convention for compile-time constant names+    caseConventionsConstant :: Util.CaseConvention,+    -- | Convention for each directory level in the emitted source tree+    caseConventionsDirectory :: Util.CaseConvention,+    -- | Convention for enum-variant value names+    caseConventionsEnumValue :: Util.CaseConvention,+    -- | Convention for record field names+    caseConventionsField :: Util.CaseConvention,+    -- | Convention for the source-file basename+    caseConventionsFile :: Util.CaseConvention,+    -- | Convention for a single segment of a module name+    caseConventionsModule :: Util.CaseConvention,+    -- | Convention for top-level term definitions (functions, module-level values)+    caseConventionsTerm :: Util.CaseConvention,+    -- | Convention for locally-bound term names (lambda parameters, let-bindings)+    caseConventionsTermVariable :: Util.CaseConvention,+    -- | Convention for type names+    caseConventionsType :: Util.CaseConvention,+    -- | Convention for type-level variable names+    caseConventionsTypeVariable :: Util.CaseConvention}+  deriving (Eq, Ord, Read, Show)+_CaseConventions = Core.Name "hydra.coders.CaseConventions"+_CaseConventions_constant = Core.Name "constant"+_CaseConventions_directory = Core.Name "directory"+_CaseConventions_enumValue = Core.Name "enumValue"+_CaseConventions_field = Core.Name "field"+_CaseConventions_file = Core.Name "file"+_CaseConventions_module = Core.Name "module"+_CaseConventions_term = Core.Name "term"+_CaseConventions_termVariable = Core.Name "termVariable"+_CaseConventions_type = Core.Name "type"+_CaseConventions_typeVariable = Core.Name "typeVariable"+-- | An encoder and decoder; a bidirectional transformation between two types+data Coder v1 v2 =+  Coder {+    -- | A function which encodes source values as target values, given an InferenceContext for fresh-variable state and subterm-path tracing+    coderEncode :: (Typing.InferenceContext -> v1 -> Either Errors.Error v2),+    -- | A function which decodes target values as source values, given an InferenceContext for fresh-variable state and subterm-path tracing+    coderDecode :: (Typing.InferenceContext -> v2 -> Either Errors.Error v1)}+_Coder = Core.Name "hydra.coders.Coder"+_Coder_encode = Core.Name "encode"+_Coder_decode = Core.Name "decode"+-- | Indicates either the 'out' or the 'in' direction of a coder+data CoderDirection =+  CoderDirectionEncode |+  CoderDirectionDecode+  deriving (Eq, Ord, Read, Show)+_CoderDirection = Core.Name "hydra.coders.CoderDirection"+_CoderDirection_encode = Core.Name "encode"+_CoderDirection_decode = Core.Name "decode"+-- | A named language together with its grammar constraints, capability profile, naming conventions, and conventional file extension+data Language =+  Language {+    -- | The unique name of the language+    languageName :: LanguageName,+    -- | Constraints which characterize the language's type and term grammars+    languageConstraints :: LanguageConstraints,+    -- | Target-language or target-runtime capabilities the emitter may assume are available+    languageSupportedFeatures :: (S.Set LanguageFeature),+    -- | Per-target case conventions for the various kinds of identifiers emitted by the coder+    languageCaseConventions :: CaseConventions,+    -- | Conventional file extension for emitted source files, without the leading dot (e.g. "scala", "py")+    languageDefaultFileExtension :: Util.FileExtension}+_Language = Core.Name "hydra.coders.Language"+_Language_name = Core.Name "name"+_Language_constraints = Core.Name "constraints"+_Language_supportedFeatures = Core.Name "supportedFeatures"+_Language_caseConventions = Core.Name "caseConventions"+_Language_defaultFileExtension = Core.Name "defaultFileExtension"+-- | A set of constraints on valid type and term expressions, characterizing a language+data LanguageConstraints =+  LanguageConstraints {+    -- | All supported literal variants+    languageConstraintsLiteralVariants :: (S.Set Variants.LiteralVariant),+    -- | All supported float types+    languageConstraintsFloatTypes :: (S.Set Core.FloatType),+    -- | All supported integer types+    languageConstraintsIntegerTypes :: (S.Set Core.IntegerType),+    -- | All supported term variants+    languageConstraintsTermVariants :: (S.Set Variants.TermVariant),+    -- | All supported type variants+    languageConstraintsTypeVariants :: (S.Set Variants.TypeVariant),+    -- | A logical set of types, as a predicate which tests a type for inclusion+    languageConstraintsTypes :: (Core.Type -> Bool)}+_LanguageConstraints = Core.Name "hydra.coders.LanguageConstraints"+_LanguageConstraints_literalVariants = Core.Name "literalVariants"+_LanguageConstraints_floatTypes = Core.Name "floatTypes"+_LanguageConstraints_integerTypes = Core.Name "integerTypes"+_LanguageConstraints_termVariants = Core.Name "termVariants"+_LanguageConstraints_typeVariants = Core.Name "typeVariants"+_LanguageConstraints_types = Core.Name "types"+-- | A target-language or target-runtime capability the coder may rely on. Absence from a Language's supportedFeatures set means the emitter must work around the missing capability.+data LanguageFeature =+  -- | The target runtime can invoke an n-ary function with fewer than n arguments without error. When absent, the emitter eta-expands partially-applied terms.+  LanguageFeaturePartialApplication |+  -- | The target runtime can handle deeply nested case statements without stack issues. When absent, the emitter hoists cases out into top-level helpers.+  LanguageFeatureNestedCaseStatements |+  -- | The target language permits polymorphic let-bindings in expression position. When absent, the emitter hoists polymorphic lets to top level.+  LanguageFeatureNestedPolymorphicLetBindings+  deriving (Eq, Ord, Read, Show)+_LanguageFeature = Core.Name "hydra.coders.LanguageFeature"+_LanguageFeature_partialApplication = Core.Name "partialApplication"+_LanguageFeature_nestedCaseStatements = Core.Name "nestedCaseStatements"+_LanguageFeature_nestedPolymorphicLetBindings = Core.Name "nestedPolymorphicLetBindings"+-- | The unique name of a language+newtype LanguageName =+  LanguageName {+    unLanguageName :: String}+  deriving (Eq, Ord, Read, Show)+_LanguageName = Core.Name "hydra.coders.LanguageName"+-- | A bidirectional encoder which maps between the same type and term languages on either side+type SymmetricAdapter t v = (Adapter t t v v)+_SymmetricAdapter = Core.Name "hydra.coders.SymmetricAdapter"+-- | Specifies either a pre-order or post-order traversal+data TraversalOrder =+  -- | Pre-order traversal+  TraversalOrderPre |+  -- | Post-order traversal+  TraversalOrderPost+  deriving (Eq, Ord, Read, Show)+_TraversalOrder = Core.Name "hydra.coders.TraversalOrder"+_TraversalOrder_pre = Core.Name "pre"+_TraversalOrder_post = Core.Name "post"+-- | A function which maps a Hydra type to a symmetric adapter between types and terms+type TypeAdapter = (AdapterContext -> Core.Type -> Either String (SymmetricAdapter Core.Type Core.Term))+_TypeAdapter = Core.Name "hydra.coders.TypeAdapter"
+ src/main/haskell/Hydra/Constants.hs view
@@ -0,0 +1,88 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A module for tier-0 constants.++module Hydra.Constants where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Disable type checking by default, for better performance+debugInference :: Bool+debugInference = True+-- | The name used for ignored variables+ignoredVariable :: String+ignoredVariable = "_"+-- | Annotation key for type classes+keyClasses :: Core.Name+keyClasses = Core.Name "classes"+-- | Annotation key for debug identifiers+keyDebugId :: Core.Name+keyDebugId = Core.Name "debugId"+-- | Annotation key for deprecated markers+keyDeprecated :: Core.Name+keyDeprecated = Core.Name "deprecated"+-- | Annotation key for descriptions+keyDescription :: Core.Name+keyDescription = Core.Name "description"+-- | Annotation key for exclusions+keyExclude :: Core.Name+keyExclude = Core.Name "exclude"+-- | A flag which tells the language coders to encode a given encoded type as a term rather than a native type+keyFirstClassType :: Core.Name+keyFirstClassType = Core.Name "firstClassType"+-- | A counter for generating fresh type variable names+keyFreshTypeVariableCount :: Core.Name+keyFreshTypeVariableCount = Core.Name "freshTypeVariableCount"+-- | Annotation key for maximum length constraints+keyMaxLength :: Core.Name+keyMaxLength = Core.Name "maxLength"+-- | Annotation key for minimum length constraints+keyMinLength :: Core.Name+keyMinLength = Core.Name "minLength"+-- | Annotation key for preserving field names during code generation+keyPreserveFieldName :: Core.Name+keyPreserveFieldName = Core.Name "preserveFieldName"+-- | Annotation key for type information+keyType :: Core.Name+keyType = Core.Name "type"+-- | The maximum value of a 32-bit integer+maxInt32 :: Int+maxInt32 = 2147483647+-- | A maximum depth for nested computations. Currently, this is set very high because deep recursion is common in type inference over the Hydra kernel.+maxTraceDepth :: Int+maxTraceDepth = 5000+-- | Regex matching a camelCase identifier: starts with a lowercase letter, then any letters or digits.+regexCamelCase :: String+regexCamelCase = "^[a-z][a-zA-Z0-9]*$"+-- | Regex matching a Hydra namespace: dot-separated camelCase segments, each starting with a lowercase letter.+regexNamespace :: String+regexNamespace = "^[a-z][a-zA-Z0-9]*(\\.[a-z][a-zA-Z0-9]*)*$"+-- | Regex matching a Hydra package name: hyphen-separated lowercase segments, each starting with a letter.+regexPackageName :: String+regexPackageName = "^[a-z][a-z0-9]*(-[a-z][a-z0-9]*)*$"+-- | Regex matching a PascalCase identifier: starts with an uppercase letter, then any letters or digits.+regexPascalCase :: String+regexPascalCase = "^[A-Z][a-zA-Z0-9]*$"+-- | A standard warning message for auto-generated files+warningAutoGeneratedFile :: String+warningAutoGeneratedFile = "Note: this is an automatically generated file. Do not edit."
+ src/main/haskell/Hydra/Core.hs view
@@ -0,0 +1,544 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Hydra's core data model, consisting of the fundamental hydra.core.Term type and all of its dependencies.++module Hydra.Core where+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.ByteString as B+import qualified Data.Int as I+import qualified Data.Map as M+import qualified Data.Set as S+-- | A term together with an annotation+data AnnotatedTerm =+  AnnotatedTerm {+    -- | The term being annotated+    annotatedTermBody :: Term,+    -- | The annotation as a single term. By convention this is a map term (Name -> Term) so that multiple independent annotations can coexist, but applications are free to use any term shape.+    annotatedTermAnnotation :: Term}+  deriving (Eq, Ord, Read, Show)+_AnnotatedTerm = Name "hydra.core.AnnotatedTerm"+_AnnotatedTerm_body = Name "body"+_AnnotatedTerm_annotation = Name "annotation"+-- | A type together with an annotation+data AnnotatedType =+  AnnotatedType {+    -- | The type being annotated+    annotatedTypeBody :: Type,+    -- | The annotation as a single term. By convention this is a map term (Name -> Term) so that multiple independent annotations can coexist, but applications are free to use any term shape.+    annotatedTypeAnnotation :: Term}+  deriving (Eq, Ord, Read, Show)+_AnnotatedType = Name "hydra.core.AnnotatedType"+_AnnotatedType_body = Name "body"+_AnnotatedType_annotation = Name "annotation"+-- | A term which applies a function to an argument+data Application =+  Application {+    -- | The left-hand side of the application+    applicationFunction :: Term,+    -- | The right-hand side of the application+    applicationArgument :: Term}+  deriving (Eq, Ord, Read, Show)+_Application = Name "hydra.core.Application"+_Application_function = Name "function"+_Application_argument = Name "argument"+-- | The type-level analog of an application term+data ApplicationType =+  ApplicationType {+    -- | The left-hand side of the application+    applicationTypeFunction :: Type,+    -- | The right-hand side of the application+    applicationTypeArgument :: Type}+  deriving (Eq, Ord, Read, Show)+_ApplicationType = Name "hydra.core.ApplicationType"+_ApplicationType_function = Name "function"+_ApplicationType_argument = Name "argument"+-- | A field with an optional type scheme, used to bind variables to terms in a 'let' expression+data Binding =+  Binding {+    -- | The name of the bound variable+    bindingName :: Name,+    -- | The term to which the variable is bound+    bindingTerm :: Term,+    -- | The optional type scheme of the bound term+    bindingTypeScheme :: (Maybe TypeScheme)}+  deriving (Eq, Ord, Read, Show)+_Binding = Name "hydra.core.Binding"+_Binding_name = Name "name"+_Binding_term = Name "term"+_Binding_typeScheme = Name "typeScheme"+-- | A single alternative of a case statement (union elimination): the variant being matched, together with the term that handles it.+data CaseAlternative =+  CaseAlternative {+    -- | The name of the union variant matched by this alternative+    caseAlternativeName :: Name,+    -- | The handler applied to the matched variant's payload+    caseAlternativeHandler :: Term}+  deriving (Eq, Ord, Read, Show)+_CaseAlternative = Name "hydra.core.CaseAlternative"+_CaseAlternative_name = Name "name"+_CaseAlternative_handler = Name "handler"+-- | A union elimination; a case statement+data CaseStatement =+  CaseStatement {+    -- | The name of the union type+    caseStatementTypeName :: Name,+    -- | An optional default case, used if none of the explicit cases match+    caseStatementDefault :: (Maybe Term),+    -- | A list of case alternatives, one per union variant being handled+    caseStatementCases :: [CaseAlternative]}+  deriving (Eq, Ord, Read, Show)+_CaseStatement = Name "hydra.core.CaseStatement"+_CaseStatement_typeName = Name "typeName"+_CaseStatement_default = Name "default"+_CaseStatement_cases = Name "cases"+-- | A type which provides a choice between a 'left' type and a 'right' type+data EitherType =+  EitherType {+    -- | The 'left' alternative+    eitherTypeLeft :: Type,+    -- | The 'right' alternative+    eitherTypeRight :: Type}+  deriving (Eq, Ord, Read, Show)+_EitherType = Name "hydra.core.EitherType"+_EitherType_left = Name "left"+_EitherType_right = Name "right"+-- | A name/term pair+data Field =+  Field {+    -- | The name of the field+    fieldName :: Name,+    -- | The value of the field+    fieldTerm :: Term}+  deriving (Eq, Ord, Read, Show)+_Field = Name "hydra.core.Field"+_Field_name = Name "name"+_Field_term = Name "term"+-- | A name/type pair+data FieldType =+  FieldType {+    -- | The name of the field+    fieldTypeName :: Name,+    -- | The type of the field+    fieldTypeType :: Type}+  deriving (Eq, Ord, Read, Show)+_FieldType = Name "hydra.core.FieldType"+_FieldType_name = Name "name"+_FieldType_type = Name "type"+-- | A floating-point type+data FloatType =+  -- | A 32-bit floating-point type+  FloatTypeFloat32 |+  -- | A 64-bit floating-point type+  FloatTypeFloat64+  deriving (Eq, Ord, Read, Show)+_FloatType = Name "hydra.core.FloatType"+_FloatType_float32 = Name "float32"+_FloatType_float64 = Name "float64"+-- | A floating-point literal value+data FloatValue =+  -- | A 32-bit floating-point value+  FloatValueFloat32 Float |+  -- | A 64-bit floating-point value+  FloatValueFloat64 Double+  deriving (Eq, Ord, Read, Show)+_FloatValue = Name "hydra.core.FloatValue"+_FloatValue_float32 = Name "float32"+_FloatValue_float64 = Name "float64"+-- | A universally quantified type; the System F equivalent of a type scheme, and the type-level equivalent of a lambda term.+data ForallType =+  ForallType {+    -- | The variable which is bound by the lambda+    forallTypeParameter :: Name,+    -- | The body of the lambda+    forallTypeBody :: Type}+  deriving (Eq, Ord, Read, Show)+_ForallType = Name "hydra.core.ForallType"+_ForallType_parameter = Name "parameter"+_ForallType_body = Name "body"+-- | A function type, also known as an arrow type+data FunctionType =+  FunctionType {+    -- | The domain (input) type of the function+    functionTypeDomain :: Type,+    -- | The codomain (output) type of the function+    functionTypeCodomain :: Type}+  deriving (Eq, Ord, Read, Show)+_FunctionType = Name "hydra.core.FunctionType"+_FunctionType_domain = Name "domain"+_FunctionType_codomain = Name "codomain"+-- | An instance of a union type; i.e. a string-indexed generalization of inl() or inr()+data Injection =+  Injection {+    -- | The name of the union type+    injectionTypeName :: Name,+    -- | The field being injected, including its name and value+    injectionField :: Field}+  deriving (Eq, Ord, Read, Show)+_Injection = Name "hydra.core.Injection"+_Injection_typeName = Name "typeName"+_Injection_field = Name "field"+-- | An integer type+data IntegerType =+  -- | An arbitrary-precision integer type+  IntegerTypeBigint |+  -- | An 8-bit signed integer type+  IntegerTypeInt8 |+  -- | A 16-bit signed integer type+  IntegerTypeInt16 |+  -- | A 32-bit signed integer type+  IntegerTypeInt32 |+  -- | A 64-bit signed integer type+  IntegerTypeInt64 |+  -- | An 8-bit unsigned integer type+  IntegerTypeUint8 |+  -- | A 16-bit unsigned integer type+  IntegerTypeUint16 |+  -- | A 32-bit unsigned integer type+  IntegerTypeUint32 |+  -- | A 64-bit unsigned integer type+  IntegerTypeUint64+  deriving (Eq, Ord, Read, Show)+_IntegerType = Name "hydra.core.IntegerType"+_IntegerType_bigint = Name "bigint"+_IntegerType_int8 = Name "int8"+_IntegerType_int16 = Name "int16"+_IntegerType_int32 = Name "int32"+_IntegerType_int64 = Name "int64"+_IntegerType_uint8 = Name "uint8"+_IntegerType_uint16 = Name "uint16"+_IntegerType_uint32 = Name "uint32"+_IntegerType_uint64 = Name "uint64"+-- | An integer literal value+data IntegerValue =+  -- | An arbitrary-precision integer value+  IntegerValueBigint Integer |+  -- | An 8-bit signed integer value+  IntegerValueInt8 I.Int8 |+  -- | A 16-bit signed integer value (short value)+  IntegerValueInt16 I.Int16 |+  -- | A 32-bit signed integer value (int value)+  IntegerValueInt32 Int |+  -- | A 64-bit signed integer value (long value)+  IntegerValueInt64 I.Int64 |+  -- | An 8-bit unsigned integer value (byte)+  IntegerValueUint8 I.Int16 |+  -- | A 16-bit unsigned integer value+  IntegerValueUint16 Int |+  -- | A 32-bit unsigned integer value (unsigned int)+  IntegerValueUint32 I.Int64 |+  -- | A 64-bit unsigned integer value (unsigned long)+  IntegerValueUint64 Integer+  deriving (Eq, Ord, Read, Show)+_IntegerValue = Name "hydra.core.IntegerValue"+_IntegerValue_bigint = Name "bigint"+_IntegerValue_int8 = Name "int8"+_IntegerValue_int16 = Name "int16"+_IntegerValue_int32 = Name "int32"+_IntegerValue_int64 = Name "int64"+_IntegerValue_uint8 = Name "uint8"+_IntegerValue_uint16 = Name "uint16"+_IntegerValue_uint32 = Name "uint32"+_IntegerValue_uint64 = Name "uint64"+-- | A function abstraction (lambda)+data Lambda =+  Lambda {+    -- | The parameter of the lambda+    lambdaParameter :: Name,+    -- | An optional domain type for the lambda+    lambdaDomain :: (Maybe Type),+    -- | The body of the lambda+    lambdaBody :: Term}+  deriving (Eq, Ord, Read, Show)+_Lambda = Name "hydra.core.Lambda"+_Lambda_parameter = Name "parameter"+_Lambda_domain = Name "domain"+_Lambda_body = Name "body"+-- | A set of (possibly recursive) 'let' bindings together with a body in which they are bound+data Let =+  Let {+    -- | The list of variable bindings+    letBindings :: [Binding],+    -- | The body term in which the variables are bound+    letBody :: Term}+  deriving (Eq, Ord, Read, Show)+_Let = Name "hydra.core.Let"+_Let_bindings = Name "bindings"+_Let_body = Name "body"+-- | A term constant; an instance of a literal type+data Literal =+  -- | A binary literal+  LiteralBinary B.ByteString |+  -- | A boolean literal+  LiteralBoolean Bool |+  -- | An arbitrary-precision decimal literal+  LiteralDecimal Sci.Scientific |+  -- | A floating-point literal+  LiteralFloat FloatValue |+  -- | An integer literal+  LiteralInteger IntegerValue |+  -- | A string literal+  LiteralString String+  deriving (Eq, Ord, Read, Show)+_Literal = Name "hydra.core.Literal"+_Literal_binary = Name "binary"+_Literal_boolean = Name "boolean"+_Literal_decimal = Name "decimal"+_Literal_float = Name "float"+_Literal_integer = Name "integer"+_Literal_string = Name "string"+-- | Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants+data LiteralType =+  -- | The type of a binary (byte string) value+  LiteralTypeBinary |+  -- | The type of a boolean (true/false) value+  LiteralTypeBoolean |+  -- | The type of an arbitrary-precision decimal value+  LiteralTypeDecimal |+  -- | The type of a floating-point value+  LiteralTypeFloat FloatType |+  -- | The type of an integer value+  LiteralTypeInteger IntegerType |+  -- | The type of a string value+  LiteralTypeString+  deriving (Eq, Ord, Read, Show)+_LiteralType = Name "hydra.core.LiteralType"+_LiteralType_binary = Name "binary"+_LiteralType_boolean = Name "boolean"+_LiteralType_decimal = Name "decimal"+_LiteralType_float = Name "float"+_LiteralType_integer = Name "integer"+_LiteralType_string = Name "string"+-- | A map type+data MapType =+  MapType {+    -- | The type of keys in the map+    mapTypeKeys :: Type,+    -- | The type of values in the map+    mapTypeValues :: Type}+  deriving (Eq, Ord, Read, Show)+_MapType = Name "hydra.core.MapType"+_MapType_keys = Name "keys"+_MapType_values = Name "values"+-- | A unique identifier in some context; a string-valued key+newtype Name =+  Name {+    unName :: String}+  deriving (Eq, Ord, Read, Show)+_Name = Name "hydra.core.Name"+-- | A type which pairs a 'first' type and a 'second' type+data PairType =+  PairType {+    -- | The first component of the pair+    pairTypeFirst :: Type,+    -- | The second component of the pair+    pairTypeSecond :: Type}+  deriving (Eq, Ord, Read, Show)+_PairType = Name "hydra.core.PairType"+_PairType_first = Name "first"+_PairType_second = Name "second"+-- | A record elimination; a projection+data Projection =+  Projection {+    -- | The name of the record type+    projectionTypeName :: Name,+    -- | The name of the projected field+    projectionFieldName :: Name}+  deriving (Eq, Ord, Read, Show)+_Projection = Name "hydra.core.Projection"+_Projection_typeName = Name "typeName"+_Projection_fieldName = Name "fieldName"+-- | A record, or labeled tuple; a map of field names to terms+data Record =+  Record {+    -- | The name of the record type+    recordTypeName :: Name,+    -- | The fields of the record, as a list of name/term pairs+    recordFields :: [Field]}+  deriving (Eq, Ord, Read, Show)+_Record = Name "hydra.core.Record"+_Record_typeName = Name "typeName"+_Record_fields = Name "fields"+-- | A data term+data Term =+  -- | A term annotated with metadata+  TermAnnotated AnnotatedTerm |+  -- | A function application+  TermApplication Application |+  -- | A union elimination; a case statement+  TermCases CaseStatement |+  -- | An either value+  TermEither (Either Term Term) |+  -- | An injection; an instance of a union type+  TermInject Injection |+  -- | A function abstraction (lambda)+  TermLambda Lambda |+  -- | A 'let' term, which binds variables to terms+  TermLet Let |+  -- | A list+  TermList [Term] |+  -- | A literal value+  TermLiteral Literal |+  -- | A map of keys to values+  TermMap (M.Map Term Term) |+  -- | An optional value+  TermOptional (Maybe Term) |+  -- | A pair (2-tuple)+  TermPair (Term, Term) |+  -- | A record elimination; a projection+  TermProject Projection |+  -- | A record term+  TermRecord Record |+  -- | A set of values+  TermSet (S.Set Term) |+  -- | A System F type application term+  TermTypeApplication TypeApplicationTerm |+  -- | A System F type abstraction term+  TermTypeLambda TypeLambda |+  -- | A unit value; a term with no value+  TermUnit |+  -- | An unwrap elimination; the inverse of a wrap. Given the name of a wrapper type, unwraps an instance of that type to its underlying body value.+  TermUnwrap Name |+  -- | A variable reference+  TermVariable Name |+  -- | A wrapped term; an instance of a wrapper type (newtype)+  TermWrap WrappedTerm+  deriving (Eq, Ord, Read, Show)+_Term = Name "hydra.core.Term"+_Term_annotated = Name "annotated"+_Term_application = Name "application"+_Term_cases = Name "cases"+_Term_either = Name "either"+_Term_inject = Name "inject"+_Term_lambda = Name "lambda"+_Term_let = Name "let"+_Term_list = Name "list"+_Term_literal = Name "literal"+_Term_map = Name "map"+_Term_optional = Name "optional"+_Term_pair = Name "pair"+_Term_project = Name "project"+_Term_record = Name "record"+_Term_set = Name "set"+_Term_typeApplication = Name "typeApplication"+_Term_typeLambda = Name "typeLambda"+_Term_unit = Name "unit"+_Term_unwrap = Name "unwrap"+_Term_variable = Name "variable"+_Term_wrap = Name "wrap"+-- | A data type+data Type =+  -- | An annotated type+  TypeAnnotated AnnotatedType |+  -- | A type application+  TypeApplication ApplicationType |+  -- | An either (sum) type+  TypeEither EitherType |+  -- | A universally quantified (polymorphic) type+  TypeForall ForallType |+  -- | A function type+  TypeFunction FunctionType |+  -- | A list type+  TypeList Type |+  -- | A literal type+  TypeLiteral LiteralType |+  -- | A map type+  TypeMap MapType |+  -- | An optional type+  TypeOptional Type |+  -- | A pair (2-tuple) type+  TypePair PairType |+  -- | A record type+  TypeRecord [FieldType] |+  -- | A set type+  TypeSet Type |+  -- | A union type with field names+  TypeUnion [FieldType] |+  -- | The unit type — the nullary conjunction; one inhabitant. Dual to `void`.+  TypeUnit |+  -- | A type variable+  TypeVariable Name |+  -- | The void (uninhabited, or bottom) type — the nullary disjunction; zero inhabitants. Dual to `unit`.+  TypeVoid |+  -- | A wrapped type (newtype). There is no corresponding `unwrap` variant at the type level: wrap is the introduction form, and a wrapper type's underlying body type is given by the `wrap` variant's argument.+  TypeWrap Type+  deriving (Eq, Ord, Read, Show)+_Type = Name "hydra.core.Type"+_Type_annotated = Name "annotated"+_Type_application = Name "application"+_Type_either = Name "either"+_Type_forall = Name "forall"+_Type_function = Name "function"+_Type_list = Name "list"+_Type_literal = Name "literal"+_Type_map = Name "map"+_Type_optional = Name "optional"+_Type_pair = Name "pair"+_Type_record = Name "record"+_Type_set = Name "set"+_Type_union = Name "union"+_Type_unit = Name "unit"+_Type_variable = Name "variable"+_Type_void = Name "void"+_Type_wrap = Name "wrap"+-- | A term applied to a type; a type application.+data TypeApplicationTerm =+  TypeApplicationTerm {+    -- | The term being applied to a type+    typeApplicationTermBody :: Term,+    -- | The type argument+    typeApplicationTermType :: Type}+  deriving (Eq, Ord, Read, Show)+_TypeApplicationTerm = Name "hydra.core.TypeApplicationTerm"+_TypeApplicationTerm_body = Name "body"+_TypeApplicationTerm_type = Name "type"+-- | A type class constraint on a type variable. Currently has only one variant, but designed to be forward-compatible with multi-parameter type classes and constraints on type expressions.+data TypeClassConstraint =+  -- | A simple type class constraint, naming a single type class+  TypeClassConstraintSimple Name+  deriving (Eq, Ord, Read, Show)+_TypeClassConstraint = Name "hydra.core.TypeClassConstraint"+_TypeClassConstraint_simple = Name "simple"+-- | A System F type abstraction term+data TypeLambda =+  TypeLambda {+    -- | The type variable introduced by the abstraction+    typeLambdaParameter :: Name,+    -- | The body of the abstraction+    typeLambdaBody :: Term}+  deriving (Eq, Ord, Read, Show)+_TypeLambda = Name "hydra.core.TypeLambda"+_TypeLambda_parameter = Name "parameter"+_TypeLambda_body = Name "body"+-- | A type expression together with free type variables occurring in the expression+data TypeScheme =+  TypeScheme {+    -- | The free type variables+    typeSchemeVariables :: [Name],+    -- | The type expression+    typeSchemeBody :: Type,+    -- | Optional constraints on type variables, including typeclass constraints. The map keys are type variable names.+    typeSchemeConstraints :: (Maybe (M.Map Name TypeVariableConstraints))}+  deriving (Eq, Ord, Read, Show)+_TypeScheme = Name "hydra.core.TypeScheme"+_TypeScheme_variables = Name "variables"+_TypeScheme_body = Name "body"+_TypeScheme_constraints = Name "constraints"+-- | Constraints associated with a type variable, including typeclass constraints+data TypeVariableConstraints =+  TypeVariableConstraints {+    -- | The typeclass constraints on this type variable+    typeVariableConstraintsClasses :: [TypeClassConstraint]}+  deriving (Eq, Ord, Read, Show)+_TypeVariableConstraints = Name "hydra.core.TypeVariableConstraints"+_TypeVariableConstraints_classes = Name "classes"+-- | A term wrapped in a type name+data WrappedTerm =+  WrappedTerm {+    -- | The name of the wrapper type+    wrappedTermTypeName :: Name,+    -- | The wrapped term+    wrappedTermBody :: Term}+  deriving (Eq, Ord, Read, Show)+_WrappedTerm = Name "hydra.core.WrappedTerm"+_WrappedTerm_typeName = Name "typeName"+_WrappedTerm_body = Name "body"
+ src/main/haskell/Hydra/Decode/Ast.hs view
@@ -0,0 +1,232 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.ast++module Hydra.Decode.Ast where+import qualified Hydra.Ast as Ast+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 Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Decoder for hydra.ast.Associativity+associativity :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Associativity+associativity 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 "none", (\input -> Eithers.map (\t -> Ast.AssociativityNone) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "left", (\input -> Eithers.map (\t -> Ast.AssociativityLeft) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "right", (\input -> Eithers.map (\t -> Ast.AssociativityRight) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "both", (\input -> Eithers.map (\t -> Ast.AssociativityBoth) (ExtractCore.decodeUnit 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.ast.BlockStyle+blockStyle :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.BlockStyle+blockStyle cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "indent" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> 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 cx2 raw2))) fieldMap cx) (\field_indent -> Eithers.bind (ExtractCore.requireField "newlineBeforeContent" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_newlineBeforeContent -> Eithers.bind (ExtractCore.requireField "newlineAfterContent" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_newlineAfterContent -> Right (Ast.BlockStyle {+          Ast.blockStyleIndent = field_indent,+          Ast.blockStyleNewlineBeforeContent = field_newlineBeforeContent,+          Ast.blockStyleNewlineAfterContent = field_newlineAfterContent})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.BlockStyle")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.BracketExpr+bracketExpr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.BracketExpr+bracketExpr cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "brackets" brackets fieldMap cx) (\field_brackets -> Eithers.bind (ExtractCore.requireField "enclosed" expr fieldMap cx) (\field_enclosed -> Eithers.bind (ExtractCore.requireField "style" blockStyle fieldMap cx) (\field_style -> Right (Ast.BracketExpr {+          Ast.bracketExprBrackets = field_brackets,+          Ast.bracketExprEnclosed = field_enclosed,+          Ast.bracketExprStyle = field_style})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.BracketExpr")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.Brackets+brackets :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Brackets+brackets cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "open" symbol fieldMap cx) (\field_open -> Eithers.bind (ExtractCore.requireField "close" symbol fieldMap cx) (\field_close -> Right (Ast.Brackets {+          Ast.bracketsOpen = field_open,+          Ast.bracketsClose = field_close}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.Brackets")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.Expr+expr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Expr+expr 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 "const", (\input -> Eithers.map (\t -> Ast.ExprConst t) (symbol cx input))),+                      (Core.Name "indent", (\input -> Eithers.map (\t -> Ast.ExprIndent t) (indentedExpression cx input))),+                      (Core.Name "op", (\input -> Eithers.map (\t -> Ast.ExprOp t) (opExpr cx input))),+                      (Core.Name "brackets", (\input -> Eithers.map (\t -> Ast.ExprBrackets t) (bracketExpr cx input))),+                      (Core.Name "seq", (\input -> Eithers.map (\t -> Ast.ExprSeq t) (seqExpr 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.ast.IndentStyle+indentStyle :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.IndentStyle+indentStyle 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 "allLines",+                        (\input -> Eithers.map (\t -> Ast.IndentStyleAllLines 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)))),+                      (+                        Core.Name "subsequentLines",+                        (\input -> Eithers.map (\t -> Ast.IndentStyleSubsequentLines 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)+-- | Decoder for hydra.ast.IndentedExpression+indentedExpression :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.IndentedExpression+indentedExpression cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "style" indentStyle fieldMap cx) (\field_style -> Eithers.bind (ExtractCore.requireField "expr" expr fieldMap cx) (\field_expr -> Right (Ast.IndentedExpression {+          Ast.indentedExpressionStyle = field_style,+          Ast.indentedExpressionExpr = field_expr}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.IndentedExpression")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.Op+op :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Op+op cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "symbol" symbol fieldMap cx) (\field_symbol -> Eithers.bind (ExtractCore.requireField "padding" padding fieldMap cx) (\field_padding -> Eithers.bind (ExtractCore.requireField "precedence" precedence fieldMap cx) (\field_precedence -> Eithers.bind (ExtractCore.requireField "associativity" associativity fieldMap cx) (\field_associativity -> Right (Ast.Op {+          Ast.opSymbol = field_symbol,+          Ast.opPadding = field_padding,+          Ast.opPrecedence = field_precedence,+          Ast.opAssociativity = field_associativity}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.Op")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.OpExpr+opExpr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.OpExpr+opExpr cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "op" op fieldMap cx) (\field_op -> Eithers.bind (ExtractCore.requireField "lhs" expr fieldMap cx) (\field_lhs -> Eithers.bind (ExtractCore.requireField "rhs" expr fieldMap cx) (\field_rhs -> Right (Ast.OpExpr {+          Ast.opExprOp = field_op,+          Ast.opExprLhs = field_lhs,+          Ast.opExprRhs = field_rhs})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.OpExpr")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.Padding+padding :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Padding+padding cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "left" ws fieldMap cx) (\field_left -> Eithers.bind (ExtractCore.requireField "right" ws fieldMap cx) (\field_right -> Right (Ast.Padding {+          Ast.paddingLeft = field_left,+          Ast.paddingRight = field_right}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.Padding")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.Precedence+precedence :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Precedence+precedence cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Ast.Precedence b) ((\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 cx raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.SeqExpr+seqExpr :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.SeqExpr+seqExpr cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "op" op fieldMap cx) (\field_op -> Eithers.bind (ExtractCore.requireField "elements" (ExtractCore.decodeList expr) fieldMap cx) (\field_elements -> Right (Ast.SeqExpr {+          Ast.seqExprOp = field_op,+          Ast.seqExprElements = field_elements}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.ast.SeqExpr")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.Symbol+symbol :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Symbol+symbol cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Ast.Symbol b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.ast.Ws+ws :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Ast.Ws+ws 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 "none", (\input -> Eithers.map (\t -> Ast.WsNone) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "space", (\input -> Eithers.map (\t -> Ast.WsSpace) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "break", (\input -> Eithers.map (\t -> Ast.WsBreak) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "breakAndIndent",+                        (\input -> Eithers.map (\t -> Ast.WsBreakAndIndent 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)))),+                      (Core.Name "doubleBreak", (\input -> Eithers.map (\t -> Ast.WsDoubleBreak) (ExtractCore.decodeUnit 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)
+ src/main/haskell/Hydra/Decode/Coders.hs view
@@ -0,0 +1,109 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.coders++module Hydra.Decode.Coders where+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Errors as DecodeErrors+import qualified Hydra.Decode.Typing as Typing+import qualified Hydra.Decode.Util as DecodeUtil+import qualified Hydra.Decode.Variants as Variants+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.coders.CaseConventions+caseConventions :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.CaseConventions+caseConventions cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "constant" DecodeUtil.caseConvention fieldMap cx) (\field_constant -> Eithers.bind (ExtractCore.requireField "directory" DecodeUtil.caseConvention fieldMap cx) (\field_directory -> Eithers.bind (ExtractCore.requireField "enumValue" DecodeUtil.caseConvention fieldMap cx) (\field_enumValue -> Eithers.bind (ExtractCore.requireField "field" DecodeUtil.caseConvention fieldMap cx) (\field_field -> Eithers.bind (ExtractCore.requireField "file" DecodeUtil.caseConvention fieldMap cx) (\field_file -> Eithers.bind (ExtractCore.requireField "module" DecodeUtil.caseConvention fieldMap cx) (\field_module -> Eithers.bind (ExtractCore.requireField "term" DecodeUtil.caseConvention fieldMap cx) (\field_term -> Eithers.bind (ExtractCore.requireField "termVariable" DecodeUtil.caseConvention fieldMap cx) (\field_termVariable -> Eithers.bind (ExtractCore.requireField "type" DecodeUtil.caseConvention fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "typeVariable" DecodeUtil.caseConvention fieldMap cx) (\field_typeVariable -> Right (Coders.CaseConventions {+          Coders.caseConventionsConstant = field_constant,+          Coders.caseConventionsDirectory = field_directory,+          Coders.caseConventionsEnumValue = field_enumValue,+          Coders.caseConventionsField = field_field,+          Coders.caseConventionsFile = field_file,+          Coders.caseConventionsModule = field_module,+          Coders.caseConventionsTerm = field_term,+          Coders.caseConventionsTermVariable = field_termVariable,+          Coders.caseConventionsType = field_type,+          Coders.caseConventionsTypeVariable = field_typeVariable}))))))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.coders.CaseConventions")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.coders.CoderDirection+coderDirection :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.CoderDirection+coderDirection 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 "encode", (\input -> Eithers.map (\t -> Coders.CoderDirectionEncode) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "decode", (\input -> Eithers.map (\t -> Coders.CoderDirectionDecode) (ExtractCore.decodeUnit 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.coders.LanguageFeature+languageFeature :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.LanguageFeature+languageFeature 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 "partialApplication",+                        (\input -> Eithers.map (\t -> Coders.LanguageFeaturePartialApplication) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "nestedCaseStatements",+                        (\input -> Eithers.map (\t -> Coders.LanguageFeatureNestedCaseStatements) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "nestedPolymorphicLetBindings",+                        (\input -> Eithers.map (\t -> Coders.LanguageFeatureNestedPolymorphicLetBindings) (ExtractCore.decodeUnit 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.coders.LanguageName+languageName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.LanguageName+languageName cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Coders.LanguageName b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.coders.TraversalOrder+traversalOrder :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Coders.TraversalOrder+traversalOrder 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 "pre", (\input -> Eithers.map (\t -> Coders.TraversalOrderPre) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "post", (\input -> Eithers.map (\t -> Coders.TraversalOrderPost) (ExtractCore.decodeUnit 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)
+ src/main/haskell/Hydra/Decode/Core.hs view
@@ -0,0 +1,590 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.core++module Hydra.Decode.Core where+import qualified Hydra.Core as Core+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.core.AnnotatedTerm+annotatedTerm :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.AnnotatedTerm+annotatedTerm cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "body" term fieldMap cx) (\field_body -> Eithers.bind (ExtractCore.requireField "annotation" term fieldMap cx) (\field_annotation -> Right (Core.AnnotatedTerm {+          Core.annotatedTermBody = field_body,+          Core.annotatedTermAnnotation = field_annotation}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.AnnotatedTerm")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.AnnotatedType+annotatedType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.AnnotatedType+annotatedType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "body" type_ fieldMap cx) (\field_body -> Eithers.bind (ExtractCore.requireField "annotation" term fieldMap cx) (\field_annotation -> Right (Core.AnnotatedType {+          Core.annotatedTypeBody = field_body,+          Core.annotatedTypeAnnotation = field_annotation}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.AnnotatedType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Application+application :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Application+application cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "function" term fieldMap cx) (\field_function -> Eithers.bind (ExtractCore.requireField "argument" term fieldMap cx) (\field_argument -> Right (Core.Application {+          Core.applicationFunction = field_function,+          Core.applicationArgument = field_argument}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Application")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.ApplicationType+applicationType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.ApplicationType+applicationType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "function" type_ fieldMap cx) (\field_function -> Eithers.bind (ExtractCore.requireField "argument" type_ fieldMap cx) (\field_argument -> Right (Core.ApplicationType {+          Core.applicationTypeFunction = field_function,+          Core.applicationTypeArgument = field_argument}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.ApplicationType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Binding+binding :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Binding+binding cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "term" term fieldMap cx) (\field_term -> Eithers.bind (ExtractCore.requireField "typeScheme" (ExtractCore.decodeMaybe typeScheme) fieldMap cx) (\field_typeScheme -> Right (Core.Binding {+          Core.bindingName = field_name,+          Core.bindingTerm = field_term,+          Core.bindingTypeScheme = field_typeScheme})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Binding")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.CaseAlternative+caseAlternative :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.CaseAlternative+caseAlternative cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "handler" term fieldMap cx) (\field_handler -> Right (Core.CaseAlternative {+          Core.caseAlternativeName = field_name,+          Core.caseAlternativeHandler = field_handler}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.CaseAlternative")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.CaseStatement+caseStatement :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.CaseStatement+caseStatement cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (ExtractCore.requireField "default" (ExtractCore.decodeMaybe term) fieldMap cx) (\field_default -> Eithers.bind (ExtractCore.requireField "cases" (ExtractCore.decodeList caseAlternative) fieldMap cx) (\field_cases -> Right (Core.CaseStatement {+          Core.caseStatementTypeName = field_typeName,+          Core.caseStatementDefault = field_default,+          Core.caseStatementCases = field_cases})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.CaseStatement")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.EitherType+eitherType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.EitherType+eitherType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "left" type_ fieldMap cx) (\field_left -> Eithers.bind (ExtractCore.requireField "right" type_ fieldMap cx) (\field_right -> Right (Core.EitherType {+          Core.eitherTypeLeft = field_left,+          Core.eitherTypeRight = field_right}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.EitherType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Field+field :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Field+field cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "term" term fieldMap cx) (\field_term -> Right (Core.Field {+          Core.fieldName = field_name,+          Core.fieldTerm = field_term}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Field")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.FieldType+fieldType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FieldType+fieldType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "type" type_ fieldMap cx) (\field_type -> Right (Core.FieldType {+          Core.fieldTypeName = field_name,+          Core.fieldTypeType = field_type}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.FieldType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.FloatType+floatType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FloatType+floatType 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 "float32", (\input -> Eithers.map (\t -> Core.FloatTypeFloat32) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "float64", (\input -> Eithers.map (\t -> Core.FloatTypeFloat64) (ExtractCore.decodeUnit 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.core.FloatValue+floatValue :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FloatValue+floatValue 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 "float32",+                        (\input -> Eithers.map (\t -> Core.FloatValueFloat32 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralFloat v2 -> case v2 of+                              Core.FloatValueFloat32 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected float32 value")+                            _ -> Left (Errors.DecodingError "expected float32 literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "float64",+                        (\input -> Eithers.map (\t -> Core.FloatValueFloat64 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))))]+        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.core.ForallType+forallType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.ForallType+forallType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "parameter" name fieldMap cx) (\field_parameter -> Eithers.bind (ExtractCore.requireField "body" type_ fieldMap cx) (\field_body -> Right (Core.ForallType {+          Core.forallTypeParameter = field_parameter,+          Core.forallTypeBody = field_body}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.ForallType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.FunctionType+functionType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.FunctionType+functionType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "domain" type_ fieldMap cx) (\field_domain -> Eithers.bind (ExtractCore.requireField "codomain" type_ fieldMap cx) (\field_codomain -> Right (Core.FunctionType {+          Core.functionTypeDomain = field_domain,+          Core.functionTypeCodomain = field_codomain}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.FunctionType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Injection+injection :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Injection+injection cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (ExtractCore.requireField "field" field fieldMap cx) (\field_field -> Right (Core.Injection {+          Core.injectionTypeName = field_typeName,+          Core.injectionField = field_field}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Injection")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.IntegerType+integerType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.IntegerType+integerType 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 "bigint", (\input -> Eithers.map (\t -> Core.IntegerTypeBigint) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "int8", (\input -> Eithers.map (\t -> Core.IntegerTypeInt8) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "int16", (\input -> Eithers.map (\t -> Core.IntegerTypeInt16) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "int32", (\input -> Eithers.map (\t -> Core.IntegerTypeInt32) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "int64", (\input -> Eithers.map (\t -> Core.IntegerTypeInt64) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "uint8", (\input -> Eithers.map (\t -> Core.IntegerTypeUint8) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "uint16", (\input -> Eithers.map (\t -> Core.IntegerTypeUint16) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "uint32", (\input -> Eithers.map (\t -> Core.IntegerTypeUint32) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "uint64", (\input -> Eithers.map (\t -> Core.IntegerTypeUint64) (ExtractCore.decodeUnit 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.core.IntegerValue+integerValue :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.IntegerValue+integerValue 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 "bigint",+                        (\input -> Eithers.map (\t -> Core.IntegerValueBigint 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 "int8",+                        (\input -> Eithers.map (\t -> Core.IntegerValueInt8 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralInteger v2 -> case v2 of+                              Core.IntegerValueInt8 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected int8 value")+                            _ -> Left (Errors.DecodingError "expected int8 literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "int16",+                        (\input -> Eithers.map (\t -> Core.IntegerValueInt16 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralInteger v2 -> case v2 of+                              Core.IntegerValueInt16 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected int16 value")+                            _ -> Left (Errors.DecodingError "expected int16 literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "int32",+                        (\input -> Eithers.map (\t -> Core.IntegerValueInt32 t) (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 cx input)))),+                      (+                        Core.Name "int64",+                        (\input -> Eithers.map (\t -> Core.IntegerValueInt64 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralInteger v2 -> case v2 of+                              Core.IntegerValueInt64 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected int64 value")+                            _ -> Left (Errors.DecodingError "expected int64 literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "uint8",+                        (\input -> Eithers.map (\t -> Core.IntegerValueUint8 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralInteger v2 -> case v2 of+                              Core.IntegerValueUint8 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected uint8 value")+                            _ -> Left (Errors.DecodingError "expected uint8 literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "uint16",+                        (\input -> Eithers.map (\t -> Core.IntegerValueUint16 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralInteger v2 -> case v2 of+                              Core.IntegerValueUint16 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected uint16 value")+                            _ -> Left (Errors.DecodingError "expected uint16 literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "uint32",+                        (\input -> Eithers.map (\t -> Core.IntegerValueUint32 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralInteger v2 -> case v2 of+                              Core.IntegerValueUint32 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected uint32 value")+                            _ -> Left (Errors.DecodingError "expected uint32 literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "uint64",+                        (\input -> Eithers.map (\t -> Core.IntegerValueUint64 t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralInteger v2 -> case v2 of+                              Core.IntegerValueUint64 v3 -> Right v3+                              _ -> Left (Errors.DecodingError "expected uint64 value")+                            _ -> Left (Errors.DecodingError "expected uint64 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)+-- | Decoder for hydra.core.Lambda+lambda :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Lambda+lambda cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "parameter" name fieldMap cx) (\field_parameter -> Eithers.bind (ExtractCore.requireField "domain" (ExtractCore.decodeMaybe type_) fieldMap cx) (\field_domain -> Eithers.bind (ExtractCore.requireField "body" term fieldMap cx) (\field_body -> Right (Core.Lambda {+          Core.lambdaParameter = field_parameter,+          Core.lambdaDomain = field_domain,+          Core.lambdaBody = field_body})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Lambda")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Let+let_ :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Let+let_ cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "bindings" (ExtractCore.decodeList binding) fieldMap cx) (\field_bindings -> Eithers.bind (ExtractCore.requireField "body" term fieldMap cx) (\field_body -> Right (Core.Let {+          Core.letBindings = field_bindings,+          Core.letBody = field_body}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Let")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Literal+literal :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Literal+literal 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 "binary",+                        (\input -> Eithers.map (\t -> Core.LiteralBinary t) (Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+                          Core.TermLiteral v1 -> case v1 of+                            Core.LiteralBinary v2 -> Right v2+                            _ -> Left (Errors.DecodingError "expected binary literal")+                          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),+                      (+                        Core.Name "boolean",+                        (\input -> Eithers.map (\t -> Core.LiteralBoolean 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 -> Core.LiteralDecimal 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 -> Core.LiteralFloat t) (floatValue cx input))),+                      (Core.Name "integer", (\input -> Eithers.map (\t -> Core.LiteralInteger t) (integerValue cx input))),+                      (+                        Core.Name "string",+                        (\input -> Eithers.map (\t -> Core.LiteralString 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)+-- | Decoder for hydra.core.LiteralType+literalType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.LiteralType+literalType 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 "binary", (\input -> Eithers.map (\t -> Core.LiteralTypeBinary) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "boolean", (\input -> Eithers.map (\t -> Core.LiteralTypeBoolean) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "decimal", (\input -> Eithers.map (\t -> Core.LiteralTypeDecimal) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "float", (\input -> Eithers.map (\t -> Core.LiteralTypeFloat t) (floatType cx input))),+                      (Core.Name "integer", (\input -> Eithers.map (\t -> Core.LiteralTypeInteger t) (integerType cx input))),+                      (Core.Name "string", (\input -> Eithers.map (\t -> Core.LiteralTypeString) (ExtractCore.decodeUnit 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.core.MapType+mapType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.MapType+mapType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "keys" type_ fieldMap cx) (\field_keys -> Eithers.bind (ExtractCore.requireField "values" type_ fieldMap cx) (\field_values -> Right (Core.MapType {+          Core.mapTypeKeys = field_keys,+          Core.mapTypeValues = field_values}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.MapType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Name+name :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Name+name cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Core.Name b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.PairType+pairType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.PairType+pairType 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" type_ fieldMap cx) (\field_first -> Eithers.bind (ExtractCore.requireField "second" type_ fieldMap cx) (\field_second -> Right (Core.PairType {+          Core.pairTypeFirst = field_first,+          Core.pairTypeSecond = field_second}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.PairType")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Projection+projection :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Projection+projection cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (ExtractCore.requireField "fieldName" name fieldMap cx) (\field_fieldName -> Right (Core.Projection {+          Core.projectionTypeName = field_typeName,+          Core.projectionFieldName = field_fieldName}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Projection")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Record+record :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Record+record cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (ExtractCore.requireField "fields" (ExtractCore.decodeList field) fieldMap cx) (\field_fields -> Right (Core.Record {+          Core.recordTypeName = field_typeName,+          Core.recordFields = field_fields}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.Record")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.Term+term :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Term+term 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 "annotated", (\input -> Eithers.map (\t -> Core.TermAnnotated t) (annotatedTerm cx input))),+                      (Core.Name "application", (\input -> Eithers.map (\t -> Core.TermApplication t) (application cx input))),+                      (Core.Name "cases", (\input -> Eithers.map (\t -> Core.TermCases t) (caseStatement cx input))),+                      (Core.Name "either", (\input -> Eithers.map (\t -> Core.TermEither t) (ExtractCore.decodeEither term term cx input))),+                      (Core.Name "inject", (\input -> Eithers.map (\t -> Core.TermInject t) (injection cx input))),+                      (Core.Name "lambda", (\input -> Eithers.map (\t -> Core.TermLambda t) (lambda cx input))),+                      (Core.Name "let", (\input -> Eithers.map (\t -> Core.TermLet t) (let_ cx input))),+                      (Core.Name "list", (\input -> Eithers.map (\t -> Core.TermList t) (ExtractCore.decodeList term cx input))),+                      (Core.Name "literal", (\input -> Eithers.map (\t -> Core.TermLiteral t) (literal cx input))),+                      (Core.Name "map", (\input -> Eithers.map (\t -> Core.TermMap t) (ExtractCore.decodeMap term term cx input))),+                      (Core.Name "optional", (\input -> Eithers.map (\t -> Core.TermOptional t) (ExtractCore.decodeMaybe term cx input))),+                      (Core.Name "pair", (\input -> Eithers.map (\t -> Core.TermPair t) (ExtractCore.decodePair term term cx input))),+                      (Core.Name "project", (\input -> Eithers.map (\t -> Core.TermProject t) (projection cx input))),+                      (Core.Name "record", (\input -> Eithers.map (\t -> Core.TermRecord t) (record cx input))),+                      (Core.Name "set", (\input -> Eithers.map (\t -> Core.TermSet t) (ExtractCore.decodeSet term cx input))),+                      (Core.Name "typeApplication", (\input -> Eithers.map (\t -> Core.TermTypeApplication t) (typeApplicationTerm cx input))),+                      (Core.Name "typeLambda", (\input -> Eithers.map (\t -> Core.TermTypeLambda t) (typeLambda cx input))),+                      (Core.Name "unit", (\input -> Eithers.map (\t -> Core.TermUnit) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "unwrap", (\input -> Eithers.map (\t -> Core.TermUnwrap t) (name cx input))),+                      (Core.Name "variable", (\input -> Eithers.map (\t -> Core.TermVariable t) (name cx input))),+                      (Core.Name "wrap", (\input -> Eithers.map (\t -> Core.TermWrap t) (wrappedTerm 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.core.Type+type_ :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Type+type_ 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 "annotated", (\input -> Eithers.map (\t -> Core.TypeAnnotated t) (annotatedType cx input))),+                      (Core.Name "application", (\input -> Eithers.map (\t -> Core.TypeApplication t) (applicationType cx input))),+                      (Core.Name "either", (\input -> Eithers.map (\t -> Core.TypeEither t) (eitherType cx input))),+                      (Core.Name "forall", (\input -> Eithers.map (\t -> Core.TypeForall t) (forallType cx input))),+                      (Core.Name "function", (\input -> Eithers.map (\t -> Core.TypeFunction t) (functionType cx input))),+                      (Core.Name "list", (\input -> Eithers.map (\t -> Core.TypeList t) (type_ cx input))),+                      (Core.Name "literal", (\input -> Eithers.map (\t -> Core.TypeLiteral t) (literalType cx input))),+                      (Core.Name "map", (\input -> Eithers.map (\t -> Core.TypeMap t) (mapType cx input))),+                      (Core.Name "optional", (\input -> Eithers.map (\t -> Core.TypeOptional t) (type_ cx input))),+                      (Core.Name "pair", (\input -> Eithers.map (\t -> Core.TypePair t) (pairType cx input))),+                      (Core.Name "record", (\input -> Eithers.map (\t -> Core.TypeRecord t) (ExtractCore.decodeList fieldType cx input))),+                      (Core.Name "set", (\input -> Eithers.map (\t -> Core.TypeSet t) (type_ cx input))),+                      (Core.Name "union", (\input -> Eithers.map (\t -> Core.TypeUnion t) (ExtractCore.decodeList fieldType cx input))),+                      (Core.Name "unit", (\input -> Eithers.map (\t -> Core.TypeUnit) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "variable", (\input -> Eithers.map (\t -> Core.TypeVariable t) (name cx input))),+                      (Core.Name "void", (\input -> Eithers.map (\t -> Core.TypeVoid) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "wrap", (\input -> Eithers.map (\t -> Core.TypeWrap t) (type_ 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.core.TypeApplicationTerm+typeApplicationTerm :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeApplicationTerm+typeApplicationTerm cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "body" term fieldMap cx) (\field_body -> Eithers.bind (ExtractCore.requireField "type" type_ fieldMap cx) (\field_type -> Right (Core.TypeApplicationTerm {+          Core.typeApplicationTermBody = field_body,+          Core.typeApplicationTermType = field_type}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.TypeApplicationTerm")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.TypeClassConstraint+typeClassConstraint :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeClassConstraint+typeClassConstraint 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 "simple", (\input -> Eithers.map (\t -> Core.TypeClassConstraintSimple t) (name 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.core.TypeLambda+typeLambda :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeLambda+typeLambda cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "parameter" name fieldMap cx) (\field_parameter -> Eithers.bind (ExtractCore.requireField "body" term fieldMap cx) (\field_body -> Right (Core.TypeLambda {+          Core.typeLambdaParameter = field_parameter,+          Core.typeLambdaBody = field_body}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.TypeLambda")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.TypeScheme+typeScheme :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeScheme+typeScheme cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "variables" (ExtractCore.decodeList name) fieldMap cx) (\field_variables -> Eithers.bind (ExtractCore.requireField "body" type_ fieldMap cx) (\field_body -> Eithers.bind (ExtractCore.requireField "constraints" (ExtractCore.decodeMaybe (ExtractCore.decodeMap name typeVariableConstraints)) fieldMap cx) (\field_constraints -> Right (Core.TypeScheme {+          Core.typeSchemeVariables = field_variables,+          Core.typeSchemeBody = field_body,+          Core.typeSchemeConstraints = field_constraints})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.TypeScheme")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.TypeVariableConstraints+typeVariableConstraints :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.TypeVariableConstraints+typeVariableConstraints cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "classes" (ExtractCore.decodeList typeClassConstraint) fieldMap cx) (\field_classes -> Right (Core.TypeVariableConstraints {+          Core.typeVariableConstraintsClasses = field_classes})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.TypeVariableConstraints")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.core.WrappedTerm+wrappedTerm :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.WrappedTerm+wrappedTerm cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "typeName" name fieldMap cx) (\field_typeName -> Eithers.bind (ExtractCore.requireField "body" term fieldMap cx) (\field_body -> Right (Core.WrappedTerm {+          Core.wrappedTermTypeName = field_typeName,+          Core.wrappedTermBody = field_body}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.core.WrappedTerm")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Error/Checking.hs view
@@ -0,0 +1,221 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.error.checking++module Hydra.Decode.Error.Checking where+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Paths as Paths+import qualified Hydra.Decode.Typing as Typing+import qualified Hydra.Decode.Variants as Variants+import qualified Hydra.Error.Checking as Checking+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.checking.CheckingError+checkingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.CheckingError+checkingError 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 "incorrectUnification",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorIncorrectUnification t) (incorrectUnificationError cx input))),+                      (+                        Core.Name "notAForallType",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorNotAForallType t) (notAForallTypeError cx input))),+                      (+                        Core.Name "notAFunctionType",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorNotAFunctionType t) (notAFunctionTypeError cx input))),+                      (Core.Name "other", (\input -> Eithers.map (\t -> Checking.CheckingErrorOther t) (otherCheckingError cx input))),+                      (+                        Core.Name "typeArityMismatch",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorTypeArityMismatch t) (typeArityMismatchError cx input))),+                      (+                        Core.Name "typeMismatch",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorTypeMismatch t) (typeMismatchError cx input))),+                      (+                        Core.Name "unboundTypeVariables",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorUnboundTypeVariables t) (unboundTypeVariablesError cx input))),+                      (+                        Core.Name "undefinedTermVariable",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorUndefinedTermVariable t) (undefinedTermVariableCheckingError cx input))),+                      (+                        Core.Name "unequalTypes",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorUnequalTypes t) (unequalTypesError cx input))),+                      (+                        Core.Name "unsupportedTermVariant",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorUnsupportedTermVariant t) (unsupportedTermVariantError cx input))),+                      (+                        Core.Name "untypedLambda",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorUntypedLambda t) (untypedLambdaError cx input))),+                      (+                        Core.Name "untypedLetBinding",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorUntypedLetBinding t) (untypedLetBindingError cx input))),+                      (+                        Core.Name "untypedTermVariable",+                        (\input -> Eithers.map (\t -> Checking.CheckingErrorUntypedTermVariable t) (untypedTermVariableCheckingError 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.checking.IncorrectUnificationError+incorrectUnificationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.IncorrectUnificationError+incorrectUnificationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "substitution" Typing.typeSubst fieldMap cx) (\field_substitution -> Right (Checking.IncorrectUnificationError {+          Checking.incorrectUnificationErrorSubstitution = field_substitution})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.IncorrectUnificationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.NotAForallTypeError+notAForallTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.NotAForallTypeError+notAForallTypeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "typeArguments" (ExtractCore.decodeList DecodeCore.type_) fieldMap cx) (\field_typeArguments -> Right (Checking.NotAForallTypeError {+          Checking.notAForallTypeErrorType = field_type,+          Checking.notAForallTypeErrorTypeArguments = field_typeArguments}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.NotAForallTypeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.NotAFunctionTypeError+notAFunctionTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.NotAFunctionTypeError+notAFunctionTypeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Right (Checking.NotAFunctionTypeError {+          Checking.notAFunctionTypeErrorType = field_type})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.NotAFunctionTypeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.OtherCheckingError+otherCheckingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.OtherCheckingError+otherCheckingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "path" Paths.subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "message" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_message -> Right (Checking.OtherCheckingError {+          Checking.otherCheckingErrorPath = field_path,+          Checking.otherCheckingErrorMessage = field_message}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.OtherCheckingError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.TypeArityMismatchError+typeArityMismatchError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.TypeArityMismatchError+typeArityMismatchError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "expectedArity" (\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_expectedArity -> Eithers.bind (ExtractCore.requireField "actualArity" (\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_actualArity -> Eithers.bind (ExtractCore.requireField "typeArguments" (ExtractCore.decodeList DecodeCore.type_) fieldMap cx) (\field_typeArguments -> Right (Checking.TypeArityMismatchError {+          Checking.typeArityMismatchErrorType = field_type,+          Checking.typeArityMismatchErrorExpectedArity = field_expectedArity,+          Checking.typeArityMismatchErrorActualArity = field_actualArity,+          Checking.typeArityMismatchErrorTypeArguments = field_typeArguments}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.TypeArityMismatchError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.TypeMismatchError+typeMismatchError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.TypeMismatchError+typeMismatchError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "expectedType" DecodeCore.type_ fieldMap cx) (\field_expectedType -> Eithers.bind (ExtractCore.requireField "actualType" DecodeCore.type_ fieldMap cx) (\field_actualType -> Right (Checking.TypeMismatchError {+          Checking.typeMismatchErrorExpectedType = field_expectedType,+          Checking.typeMismatchErrorActualType = field_actualType}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.TypeMismatchError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UnboundTypeVariablesError+unboundTypeVariablesError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "variables" (ExtractCore.decodeSet DecodeCore.name) fieldMap cx) (\field_variables -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Right (Checking.UnboundTypeVariablesError {+          Checking.unboundTypeVariablesErrorVariables = field_variables,+          Checking.unboundTypeVariablesErrorType = field_type}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.UnboundTypeVariablesError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "path" Paths.subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (Checking.UndefinedTermVariableCheckingError {+          Checking.undefinedTermVariableCheckingErrorPath = field_path,+          Checking.undefinedTermVariableCheckingErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.UndefinedTermVariableCheckingError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.UnequalTypesError+unequalTypesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UnequalTypesError+unequalTypesError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "types" (ExtractCore.decodeList DecodeCore.type_) fieldMap cx) (\field_types -> Eithers.bind (ExtractCore.requireField "description" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_description -> Right (Checking.UnequalTypesError {+          Checking.unequalTypesErrorTypes = field_types,+          Checking.unequalTypesErrorDescription = field_description}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.UnequalTypesError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.UnsupportedTermVariantError+unsupportedTermVariantError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UnsupportedTermVariantError+unsupportedTermVariantError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "termVariant" Variants.termVariant fieldMap cx) (\field_termVariant -> Right (Checking.UnsupportedTermVariantError {+          Checking.unsupportedTermVariantErrorTermVariant = field_termVariant})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.UnsupportedTermVariantError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.UntypedLambdaError+untypedLambdaError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UntypedLambdaError+untypedLambdaError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Right (Checking.UntypedLambdaError {+        }))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.UntypedLambdaError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.UntypedLetBindingError+untypedLetBindingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UntypedLetBindingError+untypedLetBindingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "binding" DecodeCore.binding fieldMap cx) (\field_binding -> Right (Checking.UntypedLetBindingError {+          Checking.untypedLetBindingErrorBinding = field_binding})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.UntypedLetBindingError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "path" Paths.subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (Checking.UntypedTermVariableCheckingError {+          Checking.untypedTermVariableCheckingErrorPath = field_path,+          Checking.untypedTermVariableCheckingErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.checking.UntypedTermVariableCheckingError")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Error/Core.hs view
@@ -0,0 +1,571 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.error.core++module Hydra.Decode.Error.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Paths as Paths+import qualified Hydra.Decode.Variants as Variants+import qualified Hydra.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.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.core.ConstantConditionError+constantConditionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.ConstantConditionError+constantConditionError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "value" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_value -> Right (ErrorCore.ConstantConditionError {+          ErrorCore.constantConditionErrorLocation = field_location,+          ErrorCore.constantConditionErrorValue = field_value}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.ConstantConditionError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.DuplicateBindingError+duplicateBindingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.DuplicateBindingError+duplicateBindingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.DuplicateBindingError {+          ErrorCore.duplicateBindingErrorLocation = field_location,+          ErrorCore.duplicateBindingErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.DuplicateBindingError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.DuplicateFieldError+duplicateFieldError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.DuplicateFieldError+duplicateFieldError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.DuplicateFieldError {+          ErrorCore.duplicateFieldErrorLocation = field_location,+          ErrorCore.duplicateFieldErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.DuplicateFieldError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.DuplicateRecordTypeFieldNamesError {+          ErrorCore.duplicateRecordTypeFieldNamesErrorLocation = field_location,+          ErrorCore.duplicateRecordTypeFieldNamesErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.DuplicateRecordTypeFieldNamesError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.DuplicateUnionTypeFieldNamesError {+          ErrorCore.duplicateUnionTypeFieldNamesErrorLocation = field_location,+          ErrorCore.duplicateUnionTypeFieldNamesErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.DuplicateUnionTypeFieldNamesError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.EmptyCaseStatementError+emptyCaseStatementError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.EmptyCaseStatementError+emptyCaseStatementError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "typeName" DecodeCore.name fieldMap cx) (\field_typeName -> Right (ErrorCore.EmptyCaseStatementError {+          ErrorCore.emptyCaseStatementErrorLocation = field_location,+          ErrorCore.emptyCaseStatementErrorTypeName = field_typeName}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.EmptyCaseStatementError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.EmptyLetBindingsError+emptyLetBindingsError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.EmptyLetBindingsError+emptyLetBindingsError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.EmptyLetBindingsError {+          ErrorCore.emptyLetBindingsErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.EmptyLetBindingsError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.EmptyRecordTypeError+emptyRecordTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.EmptyRecordTypeError+emptyRecordTypeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.EmptyRecordTypeError {+          ErrorCore.emptyRecordTypeErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.EmptyRecordTypeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.EmptyTermAnnotationError+emptyTermAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.EmptyTermAnnotationError+emptyTermAnnotationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.EmptyTermAnnotationError {+          ErrorCore.emptyTermAnnotationErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.EmptyTermAnnotationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.EmptyTypeAnnotationError+emptyTypeAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.EmptyTypeAnnotationError+emptyTypeAnnotationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.EmptyTypeAnnotationError {+          ErrorCore.emptyTypeAnnotationErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.EmptyTypeAnnotationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.EmptyTypeNameInTermError+emptyTypeNameInTermError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.EmptyTypeNameInTermError+emptyTypeNameInTermError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.EmptyTypeNameInTermError {+          ErrorCore.emptyTypeNameInTermErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.EmptyTypeNameInTermError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.EmptyUnionTypeError+emptyUnionTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.EmptyUnionTypeError+emptyUnionTypeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.EmptyUnionTypeError {+          ErrorCore.emptyUnionTypeErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.EmptyUnionTypeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidForallParameterNameError+invalidForallParameterNameError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.InvalidForallParameterNameError {+          ErrorCore.invalidForallParameterNameErrorLocation = field_location,+          ErrorCore.invalidForallParameterNameErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.InvalidForallParameterNameError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidLambdaParameterNameError+invalidLambdaParameterNameError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.InvalidLambdaParameterNameError {+          ErrorCore.invalidLambdaParameterNameErrorLocation = field_location,+          ErrorCore.invalidLambdaParameterNameErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.InvalidLambdaParameterNameError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidLetBindingNameError+invalidLetBindingNameError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.InvalidLetBindingNameError {+          ErrorCore.invalidLetBindingNameErrorLocation = field_location,+          ErrorCore.invalidLetBindingNameErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.InvalidLetBindingNameError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.InvalidLiteralError+invalidLiteralError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidLiteralError+invalidLiteralError 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 "typeMismatch",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidLiteralErrorTypeMismatch t) (literalTypeMismatchError 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.core.InvalidTermError+invalidTermError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidTermError+invalidTermError 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 "constantCondition",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorConstantCondition t) (constantConditionError cx input))),+                      (+                        Core.Name "duplicateBinding",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorDuplicateBinding t) (duplicateBindingError cx input))),+                      (+                        Core.Name "duplicateField",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorDuplicateField t) (duplicateFieldError cx input))),+                      (+                        Core.Name "emptyCaseStatement",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorEmptyCaseStatement t) (emptyCaseStatementError cx input))),+                      (+                        Core.Name "emptyLetBindings",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorEmptyLetBindings t) (emptyLetBindingsError cx input))),+                      (+                        Core.Name "emptyTermAnnotation",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorEmptyTermAnnotation t) (emptyTermAnnotationError cx input))),+                      (+                        Core.Name "emptyTypeNameInTerm",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorEmptyTypeNameInTerm t) (emptyTypeNameInTermError cx input))),+                      (+                        Core.Name "invalidLambdaParameterName",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorInvalidLambdaParameterName t) (invalidLambdaParameterNameError cx input))),+                      (+                        Core.Name "invalidLetBindingName",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorInvalidLetBindingName t) (invalidLetBindingNameError cx input))),+                      (+                        Core.Name "invalidTypeLambdaParameterName",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorInvalidTypeLambdaParameterName t) (invalidTypeLambdaParameterNameError cx input))),+                      (+                        Core.Name "nestedTermAnnotation",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorNestedTermAnnotation t) (nestedTermAnnotationError cx input))),+                      (+                        Core.Name "redundantWrapUnwrap",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorRedundantWrapUnwrap t) (redundantWrapUnwrapError cx input))),+                      (+                        Core.Name "selfApplication",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorSelfApplication t) (selfApplicationError cx input))),+                      (+                        Core.Name "termVariableShadowing",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorTermVariableShadowing t) (termVariableShadowingError cx input))),+                      (+                        Core.Name "typeVariableShadowingInTypeLambda",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorTypeVariableShadowingInTypeLambda t) (typeVariableShadowingInTypeLambdaError cx input))),+                      (+                        Core.Name "undefinedTermVariable",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUndefinedTermVariable t) (undefinedTermVariableError cx input))),+                      (+                        Core.Name "undefinedTypeVariableInBindingType",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUndefinedTypeVariableInBindingType t) (undefinedTypeVariableInBindingTypeError cx input))),+                      (+                        Core.Name "undefinedTypeVariableInLambdaDomain",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUndefinedTypeVariableInLambdaDomain t) (undefinedTypeVariableInLambdaDomainError cx input))),+                      (+                        Core.Name "undefinedTypeVariableInTypeApplication",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUndefinedTypeVariableInTypeApplication t) (undefinedTypeVariableInTypeApplicationError cx input))),+                      (+                        Core.Name "unknownPrimitiveName",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUnknownPrimitiveName t) (unknownPrimitiveNameError cx input))),+                      (+                        Core.Name "unnecessaryIdentityApplication",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUnnecessaryIdentityApplication t) (unnecessaryIdentityApplicationError cx input))),+                      (+                        Core.Name "untypedTermVariable",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUntypedTermVariable t) (untypedTermVariableError 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.core.InvalidTypeError+invalidTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidTypeError+invalidTypeError 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 "duplicateRecordTypeFieldNames",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorDuplicateRecordTypeFieldNames t) (duplicateRecordTypeFieldNamesError cx input))),+                      (+                        Core.Name "duplicateUnionTypeFieldNames",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorDuplicateUnionTypeFieldNames t) (duplicateUnionTypeFieldNamesError cx input))),+                      (+                        Core.Name "emptyRecordType",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorEmptyRecordType t) (emptyRecordTypeError cx input))),+                      (+                        Core.Name "emptyTypeAnnotation",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorEmptyTypeAnnotation t) (emptyTypeAnnotationError cx input))),+                      (+                        Core.Name "emptyUnionType",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorEmptyUnionType t) (emptyUnionTypeError cx input))),+                      (+                        Core.Name "invalidForallParameterName",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorInvalidForallParameterName t) (invalidForallParameterNameError cx input))),+                      (+                        Core.Name "invalidTypeSchemeVariableName",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorInvalidTypeSchemeVariableName t) (invalidTypeSchemeVariableNameError cx input))),+                      (+                        Core.Name "nestedTypeAnnotation",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorNestedTypeAnnotation t) (nestedTypeAnnotationError cx input))),+                      (+                        Core.Name "nonComparableMapKeyType",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorNonComparableMapKeyType t) (nonComparableMapKeyTypeError cx input))),+                      (+                        Core.Name "nonComparableSetElementType",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorNonComparableSetElementType t) (nonComparableSetElementTypeError cx input))),+                      (+                        Core.Name "singleVariantUnion",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorSingleVariantUnion t) (singleVariantUnionError cx input))),+                      (+                        Core.Name "typeVariableShadowingInForall",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorTypeVariableShadowingInForall t) (typeVariableShadowingInForallError cx input))),+                      (+                        Core.Name "undefinedTypeVariable",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorUndefinedTypeVariable t) (undefinedTypeVariableError cx input))),+                      (+                        Core.Name "voidInNonBottomPosition",+                        (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorVoidInNonBottomPosition t) (voidInNonBottomPositionError 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.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.InvalidTypeLambdaParameterNameError {+          ErrorCore.invalidTypeLambdaParameterNameErrorLocation = field_location,+          ErrorCore.invalidTypeLambdaParameterNameErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.InvalidTypeLambdaParameterNameError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.InvalidTypeSchemeVariableNameError {+          ErrorCore.invalidTypeSchemeVariableNameErrorLocation = field_location,+          ErrorCore.invalidTypeSchemeVariableNameErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.InvalidTypeSchemeVariableNameError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.LiteralTypeMismatchError+literalTypeMismatchError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "expectedType" DecodeCore.literalType fieldMap cx) (\field_expectedType -> Eithers.bind (ExtractCore.requireField "actualType" DecodeCore.literalType fieldMap cx) (\field_actualType -> Right (ErrorCore.LiteralTypeMismatchError {+          ErrorCore.literalTypeMismatchErrorExpectedType = field_expectedType,+          ErrorCore.literalTypeMismatchErrorActualType = field_actualType}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.LiteralTypeMismatchError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.NestedTermAnnotationError+nestedTermAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.NestedTermAnnotationError+nestedTermAnnotationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.NestedTermAnnotationError {+          ErrorCore.nestedTermAnnotationErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.NestedTermAnnotationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.NestedTypeAnnotationError+nestedTypeAnnotationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.NestedTypeAnnotationError+nestedTypeAnnotationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.NestedTypeAnnotationError {+          ErrorCore.nestedTypeAnnotationErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.NestedTypeAnnotationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.NonComparableMapKeyTypeError+nonComparableMapKeyTypeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "keyType" DecodeCore.type_ fieldMap cx) (\field_keyType -> Right (ErrorCore.NonComparableMapKeyTypeError {+          ErrorCore.nonComparableMapKeyTypeErrorLocation = field_location,+          ErrorCore.nonComparableMapKeyTypeErrorKeyType = field_keyType}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.NonComparableMapKeyTypeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.NonComparableSetElementTypeError+nonComparableSetElementTypeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "elementType" DecodeCore.type_ fieldMap cx) (\field_elementType -> Right (ErrorCore.NonComparableSetElementTypeError {+          ErrorCore.nonComparableSetElementTypeErrorLocation = field_location,+          ErrorCore.nonComparableSetElementTypeErrorElementType = field_elementType}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.NonComparableSetElementTypeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.RedundantWrapUnwrapError+redundantWrapUnwrapError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "typeName" DecodeCore.name fieldMap cx) (\field_typeName -> Right (ErrorCore.RedundantWrapUnwrapError {+          ErrorCore.redundantWrapUnwrapErrorLocation = field_location,+          ErrorCore.redundantWrapUnwrapErrorTypeName = field_typeName}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.RedundantWrapUnwrapError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.SelfApplicationError+selfApplicationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.SelfApplicationError+selfApplicationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.SelfApplicationError {+          ErrorCore.selfApplicationErrorLocation = field_location,+          ErrorCore.selfApplicationErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.SelfApplicationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.SingleVariantUnionError+singleVariantUnionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.SingleVariantUnionError+singleVariantUnionError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "fieldName" DecodeCore.name fieldMap cx) (\field_fieldName -> Right (ErrorCore.SingleVariantUnionError {+          ErrorCore.singleVariantUnionErrorLocation = field_location,+          ErrorCore.singleVariantUnionErrorFieldName = field_fieldName}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.SingleVariantUnionError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.TermVariableShadowingError+termVariableShadowingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.TermVariableShadowingError+termVariableShadowingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.TermVariableShadowingError {+          ErrorCore.termVariableShadowingErrorLocation = field_location,+          ErrorCore.termVariableShadowingErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.TermVariableShadowingError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.TypeVariableShadowingInForallError+typeVariableShadowingInForallError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.TypeVariableShadowingInForallError {+          ErrorCore.typeVariableShadowingInForallErrorLocation = field_location,+          ErrorCore.typeVariableShadowingInForallErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.TypeVariableShadowingInForallError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.TypeVariableShadowingInTypeLambdaError {+          ErrorCore.typeVariableShadowingInTypeLambdaErrorLocation = field_location,+          ErrorCore.typeVariableShadowingInTypeLambdaErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.TypeVariableShadowingInTypeLambdaError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UndefinedFieldError+undefinedFieldError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UndefinedFieldError+undefinedFieldError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "fieldName" DecodeCore.name fieldMap cx) (\field_fieldName -> Eithers.bind (ExtractCore.requireField "typeName" DecodeCore.name fieldMap cx) (\field_typeName -> Right (ErrorCore.UndefinedFieldError {+          ErrorCore.undefinedFieldErrorFieldName = field_fieldName,+          ErrorCore.undefinedFieldErrorTypeName = field_typeName}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UndefinedFieldError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UndefinedTermVariableError+undefinedTermVariableError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UndefinedTermVariableError+undefinedTermVariableError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UndefinedTermVariableError {+          ErrorCore.undefinedTermVariableErrorLocation = field_location,+          ErrorCore.undefinedTermVariableErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UndefinedTermVariableError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UndefinedTypeVariableError+undefinedTypeVariableError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UndefinedTypeVariableError {+          ErrorCore.undefinedTypeVariableErrorLocation = field_location,+          ErrorCore.undefinedTypeVariableErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UndefinedTypeVariableError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UndefinedTypeVariableInBindingTypeError {+          ErrorCore.undefinedTypeVariableInBindingTypeErrorLocation = field_location,+          ErrorCore.undefinedTypeVariableInBindingTypeErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UndefinedTypeVariableInBindingTypeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UndefinedTypeVariableInLambdaDomainError {+          ErrorCore.undefinedTypeVariableInLambdaDomainErrorLocation = field_location,+          ErrorCore.undefinedTypeVariableInLambdaDomainErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UndefinedTypeVariableInLambdaDomainError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UndefinedTypeVariableInTypeApplicationError {+          ErrorCore.undefinedTypeVariableInTypeApplicationErrorLocation = field_location,+          ErrorCore.undefinedTypeVariableInTypeApplicationErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UndefinedTypeVariableInTypeApplicationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UnexpectedTermVariantError+unexpectedTermVariantError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "expectedVariant" Variants.termVariant fieldMap cx) (\field_expectedVariant -> Eithers.bind (ExtractCore.requireField "actualTerm" DecodeCore.term fieldMap cx) (\field_actualTerm -> Right (ErrorCore.UnexpectedTermVariantError {+          ErrorCore.unexpectedTermVariantErrorExpectedVariant = field_expectedVariant,+          ErrorCore.unexpectedTermVariantErrorActualTerm = field_actualTerm}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UnexpectedTermVariantError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UnexpectedTypeVariantError+unexpectedTypeVariantError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "expectedVariant" Variants.typeVariant fieldMap cx) (\field_expectedVariant -> Eithers.bind (ExtractCore.requireField "actualType" DecodeCore.type_ fieldMap cx) (\field_actualType -> Right (ErrorCore.UnexpectedTypeVariantError {+          ErrorCore.unexpectedTypeVariantErrorExpectedVariant = field_expectedVariant,+          ErrorCore.unexpectedTypeVariantErrorActualType = field_actualType}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UnexpectedTypeVariantError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UnknownPrimitiveNameError+unknownPrimitiveNameError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UnknownPrimitiveNameError {+          ErrorCore.unknownPrimitiveNameErrorLocation = field_location,+          ErrorCore.unknownPrimitiveNameErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UnknownPrimitiveNameError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.UnnecessaryIdentityApplicationError {+          ErrorCore.unnecessaryIdentityApplicationErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UnnecessaryIdentityApplicationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.UntypedTermVariableError+untypedTermVariableError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.UntypedTermVariableError+untypedTermVariableError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (ErrorCore.UntypedTermVariableError {+          ErrorCore.untypedTermVariableErrorLocation = field_location,+          ErrorCore.untypedTermVariableErrorName = field_name}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.UntypedTermVariableError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.error.core.VoidInNonBottomPositionError+voidInNonBottomPositionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ErrorCore.VoidInNonBottomPositionError+voidInNonBottomPositionError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "location" Paths.subtermPath fieldMap cx) (\field_location -> Right (ErrorCore.VoidInNonBottomPositionError {+          ErrorCore.voidInNonBottomPositionErrorLocation = field_location})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.error.core.VoidInNonBottomPositionError")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Errors.hs view
@@ -0,0 +1,289 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.errors++module Hydra.Decode.Errors where+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Error.Checking as Checking+import qualified Hydra.Decode.Error.Core as ErrorCore+import qualified Hydra.Decode.Paths as Paths+import qualified Hydra.Decode.Typing as Typing+import qualified Hydra.Decode.Variants as Variants+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.errors.DecodingError+decodingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.DecodingError+decodingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Errors.DecodingError b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.EmptyListError+emptyListError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ()+emptyListError cx t = ExtractCore.decodeUnit cx t+-- | Decoder for hydra.errors.Error+error :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.Error+error 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 "checking", (\input -> Eithers.map (\t -> Errors.ErrorChecking t) (Checking.checkingError cx input))),+                      (Core.Name "decoding", (\input -> Eithers.map (\t -> Errors.ErrorDecoding t) (decodingError cx input))),+                      (+                        Core.Name "duplicateBinding",+                        (\input -> Eithers.map (\t -> Errors.ErrorDuplicateBinding t) (ErrorCore.duplicateBindingError cx input))),+                      (+                        Core.Name "duplicateField",+                        (\input -> Eithers.map (\t -> Errors.ErrorDuplicateField t) (ErrorCore.duplicateFieldError cx input))),+                      (Core.Name "extraction", (\input -> Eithers.map (\t -> Errors.ErrorExtraction t) (extractionError cx input))),+                      (Core.Name "inference", (\input -> Eithers.map (\t -> Errors.ErrorInference t) (inferenceError cx input))),+                      (+                        Core.Name "invalidLiteral",+                        (\input -> Eithers.map (\t -> Errors.ErrorInvalidLiteral t) (ErrorCore.invalidLiteralError cx input))),+                      (Core.Name "other", (\input -> Eithers.map (\t -> Errors.ErrorOther t) (otherError cx input))),+                      (Core.Name "resolution", (\input -> Eithers.map (\t -> Errors.ErrorResolution t) (resolutionError cx input))),+                      (+                        Core.Name "undefinedField",+                        (\input -> Eithers.map (\t -> Errors.ErrorUndefinedField t) (ErrorCore.undefinedFieldError cx input))),+                      (+                        Core.Name "undefinedTermVariable",+                        (\input -> Eithers.map (\t -> Errors.ErrorUndefinedTermVariable t) (ErrorCore.undefinedTermVariableError cx input))),+                      (+                        Core.Name "untypedTermVariable",+                        (\input -> Eithers.map (\t -> Errors.ErrorUntypedTermVariable t) (ErrorCore.untypedTermVariableError cx input))),+                      (+                        Core.Name "unexpectedTermVariant",+                        (\input -> Eithers.map (\t -> Errors.ErrorUnexpectedTermVariant t) (ErrorCore.unexpectedTermVariantError cx input))),+                      (+                        Core.Name "unexpectedTypeVariant",+                        (\input -> Eithers.map (\t -> Errors.ErrorUnexpectedTypeVariant t) (ErrorCore.unexpectedTypeVariantError cx input))),+                      (Core.Name "unification", (\input -> Eithers.map (\t -> Errors.ErrorUnification t) (unificationError 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.errors.ExtractionError+extractionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.ExtractionError+extractionError 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 "emptyList", (\input -> Eithers.map (\t -> Errors.ExtractionErrorEmptyList t) (emptyListError cx input))),+                      (+                        Core.Name "multipleBindings",+                        (\input -> Eithers.map (\t -> Errors.ExtractionErrorMultipleBindings t) (multipleBindingsError cx input))),+                      (+                        Core.Name "multipleFields",+                        (\input -> Eithers.map (\t -> Errors.ExtractionErrorMultipleFields t) (multipleFieldsError cx input))),+                      (+                        Core.Name "noMatchingField",+                        (\input -> Eithers.map (\t -> Errors.ExtractionErrorNoMatchingField t) (noMatchingFieldError cx input))),+                      (+                        Core.Name "noSuchBinding",+                        (\input -> Eithers.map (\t -> Errors.ExtractionErrorNoSuchBinding t) (noSuchBindingError cx input))),+                      (+                        Core.Name "notEnoughCases",+                        (\input -> Eithers.map (\t -> Errors.ExtractionErrorNotEnoughCases t) (notEnoughCasesError cx input))),+                      (+                        Core.Name "unexpectedShape",+                        (\input -> Eithers.map (\t -> Errors.ExtractionErrorUnexpectedShape t) (unexpectedShapeError 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.errors.InferenceError+inferenceError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.InferenceError+inferenceError 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 "checking", (\input -> Eithers.map (\t -> Errors.InferenceErrorChecking t) (Checking.checkingError cx input))),+                      (Core.Name "other", (\input -> Eithers.map (\t -> Errors.InferenceErrorOther t) (otherInferenceError cx input))),+                      (+                        Core.Name "unification",+                        (\input -> Eithers.map (\t -> Errors.InferenceErrorUnification t) (unificationInferenceError 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.errors.MultipleBindingsError+multipleBindingsError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.MultipleBindingsError+multipleBindingsError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (Errors.MultipleBindingsError {+          Errors.multipleBindingsErrorName = field_name})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.MultipleBindingsError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.MultipleFieldsError+multipleFieldsError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.MultipleFieldsError+multipleFieldsError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "fieldName" DecodeCore.name fieldMap cx) (\field_fieldName -> Right (Errors.MultipleFieldsError {+          Errors.multipleFieldsErrorFieldName = field_fieldName})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.MultipleFieldsError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.NoMatchingFieldError+noMatchingFieldError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.NoMatchingFieldError+noMatchingFieldError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "fieldName" DecodeCore.name fieldMap cx) (\field_fieldName -> Right (Errors.NoMatchingFieldError {+          Errors.noMatchingFieldErrorFieldName = field_fieldName})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.NoMatchingFieldError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.NoSuchBindingError+noSuchBindingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.NoSuchBindingError+noSuchBindingError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (Errors.NoSuchBindingError {+          Errors.noSuchBindingErrorName = field_name})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.NoSuchBindingError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.NoSuchPrimitiveError+noSuchPrimitiveError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.NoSuchPrimitiveError+noSuchPrimitiveError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Right (Errors.NoSuchPrimitiveError {+          Errors.noSuchPrimitiveErrorName = field_name})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.NoSuchPrimitiveError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.NotEnoughCasesError+notEnoughCasesError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ()+notEnoughCasesError cx t = ExtractCore.decodeUnit cx t+-- | Decoder for hydra.errors.OtherError+otherError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.OtherError+otherError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Errors.OtherError b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.OtherInferenceError+otherInferenceError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.OtherInferenceError+otherInferenceError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "path" Paths.subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "message" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_message -> Right (Errors.OtherInferenceError {+          Errors.otherInferenceErrorPath = field_path,+          Errors.otherInferenceErrorMessage = field_message}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.OtherInferenceError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.OtherResolutionError+otherResolutionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.OtherResolutionError+otherResolutionError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Errors.OtherResolutionError b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.ResolutionError+resolutionError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.ResolutionError+resolutionError 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 "noSuchBinding",+                        (\input -> Eithers.map (\t -> Errors.ResolutionErrorNoSuchBinding t) (noSuchBindingError cx input))),+                      (+                        Core.Name "noSuchPrimitive",+                        (\input -> Eithers.map (\t -> Errors.ResolutionErrorNoSuchPrimitive t) (noSuchPrimitiveError cx input))),+                      (+                        Core.Name "noMatchingField",+                        (\input -> Eithers.map (\t -> Errors.ResolutionErrorNoMatchingField t) (noMatchingFieldError cx input))),+                      (Core.Name "other", (\input -> Eithers.map (\t -> Errors.ResolutionErrorOther t) (otherResolutionError cx input))),+                      (+                        Core.Name "unexpectedShape",+                        (\input -> Eithers.map (\t -> Errors.ResolutionErrorUnexpectedShape t) (unexpectedShapeError 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.errors.UnexpectedShapeError+unexpectedShapeError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.UnexpectedShapeError+unexpectedShapeError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "expected" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_expected -> Eithers.bind (ExtractCore.requireField "actual" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_actual -> Right (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = field_expected,+          Errors.unexpectedShapeErrorActual = field_actual}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.UnexpectedShapeError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.UnificationError+unificationError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.UnificationError+unificationError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "leftType" DecodeCore.type_ fieldMap cx) (\field_leftType -> Eithers.bind (ExtractCore.requireField "rightType" DecodeCore.type_ fieldMap cx) (\field_rightType -> Eithers.bind (ExtractCore.requireField "message" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_message -> Right (Errors.UnificationError {+          Errors.unificationErrorLeftType = field_leftType,+          Errors.unificationErrorRightType = field_rightType,+          Errors.unificationErrorMessage = field_message})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.UnificationError")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.errors.UnificationInferenceError+unificationInferenceError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Errors.UnificationInferenceError+unificationInferenceError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "path" Paths.subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "cause" unificationError fieldMap cx) (\field_cause -> Right (Errors.UnificationInferenceError {+          Errors.unificationInferenceErrorPath = field_path,+          Errors.unificationInferenceErrorCause = field_cause}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.errors.UnificationInferenceError")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Json/Model.hs view
@@ -0,0 +1,64 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.json.model++module Hydra.Decode.Json.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.Json.Model as Model+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.json.model.Value+value :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Model.Value+value 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 "array", (\input -> Eithers.map (\t -> Model.ValueArray t) (ExtractCore.decodeList value cx input))),+                      (+                        Core.Name "boolean",+                        (\input -> Eithers.map (\t -> Model.ValueBoolean 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 "null", (\input -> Eithers.map (\t -> Model.ValueNull) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "number",+                        (\input -> Eithers.map (\t -> Model.ValueNumber 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 "object",+                        (\input -> Eithers.map (\t -> Model.ValueObject t) (ExtractCore.decodeList (ExtractCore.decodePair (\cx2 -> \raw2 -> 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 cx2 raw2)) value) cx input))),+                      (+                        Core.Name "string",+                        (\input -> Eithers.map (\t -> Model.ValueString 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)
+ src/main/haskell/Hydra/Decode/Packaging.hs view
@@ -0,0 +1,243 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.packaging++module Hydra.Decode.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Typing as Typing+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.Packaging as Packaging+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.packaging.Definition+definition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.Definition+definition 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 "term", (\input -> Eithers.map (\t -> Packaging.DefinitionTerm t) (termDefinition cx input))),+                      (Core.Name "type", (\input -> Eithers.map (\t -> Packaging.DefinitionType t) (typeDefinition cx input))),+                      (Core.Name "primitive", (\input -> Eithers.map (\t -> Packaging.DefinitionPrimitive t) (primitiveDefinition 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.packaging.DefinitionReference+definitionReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.DefinitionReference+definitionReference 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 "type", (\input -> Eithers.map (\t -> Packaging.DefinitionReferenceType t) (DecodeCore.name cx input))),+                      (Core.Name "term", (\input -> Eithers.map (\t -> Packaging.DefinitionReferenceTerm t) (DecodeCore.name cx input))),+                      (+                        Core.Name "primitive",+                        (\input -> Eithers.map (\t -> Packaging.DefinitionReferencePrimitive t) (DecodeCore.name 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.packaging.EntityMetadata+entityMetadata :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.EntityMetadata+entityMetadata cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "description" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> 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 cx2 raw2))) fieldMap cx) (\field_description -> Eithers.bind (ExtractCore.requireField "comments" (ExtractCore.decodeList (\cx2 -> \raw2 -> 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 cx2 raw2))) fieldMap cx) (\field_comments -> Eithers.bind (ExtractCore.requireField "seeAlso" (ExtractCore.decodeList entityReference) fieldMap cx) (\field_seeAlso -> Eithers.bind (ExtractCore.requireField "lifecycle" (ExtractCore.decodeMaybe lifecycleInfo) fieldMap cx) (\field_lifecycle -> Right (Packaging.EntityMetadata {+          Packaging.entityMetadataDescription = field_description,+          Packaging.entityMetadataComments = field_comments,+          Packaging.entityMetadataSeeAlso = field_seeAlso,+          Packaging.entityMetadataLifecycle = field_lifecycle}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.EntityMetadata")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.EntityReference+entityReference :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.EntityReference+entityReference 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 "package", (\input -> Eithers.map (\t -> Packaging.EntityReferencePackage t) (packageName cx input))),+                      (Core.Name "module", (\input -> Eithers.map (\t -> Packaging.EntityReferenceModule t) (moduleName cx input))),+                      (+                        Core.Name "definition",+                        (\input -> Eithers.map (\t -> Packaging.EntityReferenceDefinition t) (definitionReference 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.packaging.LifecycleInfo+lifecycleInfo :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.LifecycleInfo+lifecycleInfo cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "availableSince" (ExtractCore.decodeMaybe version) fieldMap cx) (\field_availableSince -> Eithers.bind (ExtractCore.requireField "deprecatedSince" (ExtractCore.decodeMaybe version) fieldMap cx) (\field_deprecatedSince -> Right (Packaging.LifecycleInfo {+          Packaging.lifecycleInfoAvailableSince = field_availableSince,+          Packaging.lifecycleInfoDeprecatedSince = field_deprecatedSince}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.LifecycleInfo")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.Module+module_ :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.Module+module_ cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" moduleName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "metadata" (ExtractCore.decodeMaybe entityMetadata) fieldMap cx) (\field_metadata -> Eithers.bind (ExtractCore.requireField "dependencies" (ExtractCore.decodeList moduleDependency) fieldMap cx) (\field_dependencies -> Eithers.bind (ExtractCore.requireField "definitions" (ExtractCore.decodeList definition) fieldMap cx) (\field_definitions -> Right (Packaging.Module {+          Packaging.moduleName = field_name,+          Packaging.moduleMetadata = field_metadata,+          Packaging.moduleDependencies = field_dependencies,+          Packaging.moduleDefinitions = field_definitions}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.Module")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.ModuleDependency+moduleDependency :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.ModuleDependency+moduleDependency cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "module" moduleName fieldMap cx) (\field_module -> Eithers.bind (ExtractCore.requireField "package" (ExtractCore.decodeMaybe packageName) fieldMap cx) (\field_package -> Right (Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = field_module,+          Packaging.moduleDependencyPackage = field_package}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.ModuleDependency")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.ModuleName+moduleName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.ModuleName+moduleName cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Packaging.ModuleName b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.Package+package :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.Package+package cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" packageName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "metadata" (ExtractCore.decodeMaybe entityMetadata) fieldMap cx) (\field_metadata -> Eithers.bind (ExtractCore.requireField "dependencies" (ExtractCore.decodeList packageDependency) fieldMap cx) (\field_dependencies -> Eithers.bind (ExtractCore.requireField "modules" (ExtractCore.decodeList module_) fieldMap cx) (\field_modules -> Right (Packaging.Package {+          Packaging.packageName = field_name,+          Packaging.packageMetadata = field_metadata,+          Packaging.packageDependencies = field_dependencies,+          Packaging.packageModules = field_modules}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.Package")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.PackageDependency+packageDependency :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.PackageDependency+packageDependency cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" packageName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "version" versionSpecifier fieldMap cx) (\field_version -> Right (Packaging.PackageDependency {+          Packaging.packageDependencyName = field_name,+          Packaging.packageDependencyVersion = field_version}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.PackageDependency")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.PackageName+packageName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.PackageName+packageName cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Packaging.PackageName b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.PrimitiveDefinition+primitiveDefinition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.PrimitiveDefinition+primitiveDefinition cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "metadata" (ExtractCore.decodeMaybe entityMetadata) fieldMap cx) (\field_metadata -> Eithers.bind (ExtractCore.requireField "signature" Typing.termSignature fieldMap cx) (\field_signature -> Eithers.bind (ExtractCore.requireField "isPure" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_isPure -> Eithers.bind (ExtractCore.requireField "isTotal" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_isTotal -> Eithers.bind (ExtractCore.requireField "defaultImplementation" (ExtractCore.decodeMaybe DecodeCore.term) fieldMap cx) (\field_defaultImplementation -> Right (Packaging.PrimitiveDefinition {+          Packaging.primitiveDefinitionName = field_name,+          Packaging.primitiveDefinitionMetadata = field_metadata,+          Packaging.primitiveDefinitionSignature = field_signature,+          Packaging.primitiveDefinitionIsPure = field_isPure,+          Packaging.primitiveDefinitionIsTotal = field_isTotal,+          Packaging.primitiveDefinitionDefaultImplementation = field_defaultImplementation}))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.PrimitiveDefinition")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.TermDefinition+termDefinition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.TermDefinition+termDefinition cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "metadata" (ExtractCore.decodeMaybe entityMetadata) fieldMap cx) (\field_metadata -> Eithers.bind (ExtractCore.requireField "signature" (ExtractCore.decodeMaybe Typing.termSignature) fieldMap cx) (\field_signature -> Eithers.bind (ExtractCore.requireField "body" DecodeCore.term fieldMap cx) (\field_body -> Right (Packaging.TermDefinition {+          Packaging.termDefinitionName = field_name,+          Packaging.termDefinitionMetadata = field_metadata,+          Packaging.termDefinitionSignature = field_signature,+          Packaging.termDefinitionBody = field_body}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.TermDefinition")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.TypeDefinition+typeDefinition :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.TypeDefinition+typeDefinition cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "metadata" (ExtractCore.decodeMaybe entityMetadata) fieldMap cx) (\field_metadata -> Eithers.bind (ExtractCore.requireField "body" DecodeCore.typeScheme fieldMap cx) (\field_body -> Right (Packaging.TypeDefinition {+          Packaging.typeDefinitionName = field_name,+          Packaging.typeDefinitionMetadata = field_metadata,+          Packaging.typeDefinitionBody = field_body})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.packaging.TypeDefinition")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.Version+version :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.Version+version cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Packaging.Version b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.packaging.VersionSpecifier+versionSpecifier :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Packaging.VersionSpecifier+versionSpecifier 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 "any", (\input -> Eithers.map (\t -> Packaging.VersionSpecifierAny) (ExtractCore.decodeUnit 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)
+ src/main/haskell/Hydra/Decode/Parsing.hs view
@@ -0,0 +1,68 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.parsing++module Hydra.Decode.Parsing 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.Parsing as Parsing+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.parsing.ParseError+parseError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Parsing.ParseError+parseError cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "message" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_message -> Eithers.bind (ExtractCore.requireField "remainder" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_remainder -> Right (Parsing.ParseError {+          Parsing.parseErrorMessage = field_message,+          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 a 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 "success", (\input -> Eithers.map (\t -> Parsing.ParseResultSuccess t) (parseSuccess a cx input))),+                      (Core.Name "failure", (\input -> Eithers.map (\t -> Parsing.ParseResultFailure t) (parseError 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.parsing.ParseSuccess+parseSuccess :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Parsing.ParseSuccess t0)+parseSuccess a cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "value" a fieldMap cx) (\field_value -> Eithers.bind (ExtractCore.requireField "remainder" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_remainder -> Right (Parsing.ParseSuccess {+          Parsing.parseSuccessValue = field_value,+          Parsing.parseSuccessRemainder = field_remainder}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.parsing.ParseSuccess")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Paths.hs view
@@ -0,0 +1,249 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.paths++module Hydra.Decode.Paths 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.Paths as Paths+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.paths.SubtermEdge+subtermEdge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermEdge+subtermEdge cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "source" subtermNode fieldMap cx) (\field_source -> Eithers.bind (ExtractCore.requireField "path" subtermPath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" subtermNode fieldMap cx) (\field_target -> Right (Paths.SubtermEdge {+          Paths.subtermEdgeSource = field_source,+          Paths.subtermEdgePath = field_path,+          Paths.subtermEdgeTarget = field_target})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermEdge")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtermGraph+subtermGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermGraph+subtermGraph cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "nodes" (ExtractCore.decodeList subtermNode) fieldMap cx) (\field_nodes -> Eithers.bind (ExtractCore.requireField "edges" (ExtractCore.decodeList subtermEdge) fieldMap cx) (\field_edges -> Right (Paths.SubtermGraph {+          Paths.subtermGraphNodes = field_nodes,+          Paths.subtermGraphEdges = field_edges}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermGraph")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtermNode+subtermNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermNode+subtermNode cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "label" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_label -> Eithers.bind (ExtractCore.requireField "id" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_id -> Right (Paths.SubtermNode {+          Paths.subtermNodeName = field_name,+          Paths.subtermNodeLabel = field_label,+          Paths.subtermNodeId = field_id})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtermNode")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtermPath+subtermPath :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermPath+subtermPath cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Paths.SubtermPath b) (ExtractCore.decodeList subtermStep cx (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtermStep+subtermStep :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtermStep+subtermStep 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 "annotatedBody",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepAnnotatedBody) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "applicationFunction",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepApplicationFunction) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "applicationArgument",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepApplicationArgument) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "lambdaBody", (\input -> Eithers.map (\t -> Paths.SubtermStepLambdaBody) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "unionCasesDefault",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepUnionCasesDefault) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "unionCasesBranch",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepUnionCasesBranch t) (DecodeCore.name cx input))),+                      (Core.Name "letBody", (\input -> Eithers.map (\t -> Paths.SubtermStepLetBody) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "letBinding", (\input -> Eithers.map (\t -> Paths.SubtermStepLetBinding t) (DecodeCore.name cx input))),+                      (+                        Core.Name "listElement",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepListElement t) (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 cx input)))),+                      (+                        Core.Name "mapKey",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepMapKey t) (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 cx input)))),+                      (+                        Core.Name "mapValue",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepMapValue t) (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 cx input)))),+                      (+                        Core.Name "optionalTerm",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepOptionalTerm) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "productTerm",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepProductTerm t) (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 cx input)))),+                      (Core.Name "recordField", (\input -> Eithers.map (\t -> Paths.SubtermStepRecordField t) (DecodeCore.name cx input))),+                      (+                        Core.Name "setElement",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepSetElement t) (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 cx input)))),+                      (Core.Name "sumTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepSumTerm) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "typeLambdaBody",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepTypeLambdaBody) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "typeApplicationTerm",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepTypeApplicationTerm) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "injectionTerm",+                        (\input -> Eithers.map (\t -> Paths.SubtermStepInjectionTerm) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "wrappedTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepWrappedTerm) (ExtractCore.decodeUnit 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.paths.SubtypeEdge+subtypeEdge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeEdge+subtypeEdge cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "source" subtypeNode fieldMap cx) (\field_source -> Eithers.bind (ExtractCore.requireField "path" subtypePath fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "target" subtypeNode fieldMap cx) (\field_target -> Right (Paths.SubtypeEdge {+          Paths.subtypeEdgeSource = field_source,+          Paths.subtypeEdgePath = field_path,+          Paths.subtypeEdgeTarget = field_target})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeEdge")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtypeGraph+subtypeGraph :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeGraph+subtypeGraph cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "nodes" (ExtractCore.decodeList subtypeNode) fieldMap cx) (\field_nodes -> Eithers.bind (ExtractCore.requireField "edges" (ExtractCore.decodeList subtypeEdge) fieldMap cx) (\field_edges -> Right (Paths.SubtypeGraph {+          Paths.subtypeGraphNodes = field_nodes,+          Paths.subtypeGraphEdges = field_edges}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeGraph")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtypeNode+subtypeNode :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeNode+subtypeNode cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "label" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_label -> Eithers.bind (ExtractCore.requireField "id" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_id -> Right (Paths.SubtypeNode {+          Paths.subtypeNodeName = field_name,+          Paths.subtypeNodeLabel = field_label,+          Paths.subtypeNodeId = field_id})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.paths.SubtypeNode")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtypePath+subtypePath :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypePath+subtypePath cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Paths.SubtypePath b) (ExtractCore.decodeList subtypeStep cx (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.paths.SubtypeStep+subtypeStep :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Paths.SubtypeStep+subtypeStep 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 "annotatedBody",+                        (\input -> Eithers.map (\t -> Paths.SubtypeStepAnnotatedBody) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "applicationFunction",+                        (\input -> Eithers.map (\t -> Paths.SubtypeStepApplicationFunction) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "applicationArgument",+                        (\input -> Eithers.map (\t -> Paths.SubtypeStepApplicationArgument) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "eitherLeft", (\input -> Eithers.map (\t -> Paths.SubtypeStepEitherLeft) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "eitherRight", (\input -> Eithers.map (\t -> Paths.SubtypeStepEitherRight) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "forallBody", (\input -> Eithers.map (\t -> Paths.SubtypeStepForallBody) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "functionDomain",+                        (\input -> Eithers.map (\t -> Paths.SubtypeStepFunctionDomain) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "functionCodomain",+                        (\input -> Eithers.map (\t -> Paths.SubtypeStepFunctionCodomain) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "listElement", (\input -> Eithers.map (\t -> Paths.SubtypeStepListElement) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "mapKeys", (\input -> Eithers.map (\t -> Paths.SubtypeStepMapKeys) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "mapValues", (\input -> Eithers.map (\t -> Paths.SubtypeStepMapValues) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "optionalElement",+                        (\input -> Eithers.map (\t -> Paths.SubtypeStepOptionalElement) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "pairFirst", (\input -> Eithers.map (\t -> Paths.SubtypeStepPairFirst) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "pairSecond", (\input -> Eithers.map (\t -> Paths.SubtypeStepPairSecond) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "recordField", (\input -> Eithers.map (\t -> Paths.SubtypeStepRecordField t) (DecodeCore.name cx input))),+                      (Core.Name "setElement", (\input -> Eithers.map (\t -> Paths.SubtypeStepSetElement) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "unionField", (\input -> Eithers.map (\t -> Paths.SubtypeStepUnionField t) (DecodeCore.name cx input))),+                      (Core.Name "wrappedType", (\input -> Eithers.map (\t -> Paths.SubtypeStepWrappedType) (ExtractCore.decodeUnit 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)
+ src/main/haskell/Hydra/Decode/Query.hs view
@@ -0,0 +1,272 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.query++module Hydra.Decode.Query 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.Query as Query+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.query.ComparisonConstraint+comparisonConstraint :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.ComparisonConstraint+comparisonConstraint 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 "equal", (\input -> Eithers.map (\t -> Query.ComparisonConstraintEqual) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "notEqual",+                        (\input -> Eithers.map (\t -> Query.ComparisonConstraintNotEqual) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "lessThan",+                        (\input -> Eithers.map (\t -> Query.ComparisonConstraintLessThan) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "greaterThan",+                        (\input -> Eithers.map (\t -> Query.ComparisonConstraintGreaterThan) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "lessThanOrEqual",+                        (\input -> Eithers.map (\t -> Query.ComparisonConstraintLessThanOrEqual) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "greaterThanOrEqual",+                        (\input -> Eithers.map (\t -> Query.ComparisonConstraintGreaterThanOrEqual) (ExtractCore.decodeUnit 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.query.Edge+edge :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Edge+edge cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "type" DecodeCore.name fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "out" (ExtractCore.decodeMaybe DecodeCore.name) fieldMap cx) (\field_out -> Eithers.bind (ExtractCore.requireField "in" (ExtractCore.decodeMaybe DecodeCore.name) fieldMap cx) (\field_in -> Right (Query.Edge {+          Query.edgeType = field_type,+          Query.edgeOut = field_out,+          Query.edgeIn = field_in})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.Edge")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.GraphPattern+graphPattern :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.GraphPattern+graphPattern cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "graph" DecodeCore.name fieldMap cx) (\field_graph -> Eithers.bind (ExtractCore.requireField "patterns" (ExtractCore.decodeList pattern) fieldMap cx) (\field_patterns -> Right (Query.GraphPattern {+          Query.graphPatternGraph = field_graph,+          Query.graphPatternPatterns = field_patterns}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.GraphPattern")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.Node+node :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.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 "term", (\input -> Eithers.map (\t -> Query.NodeTerm t) (DecodeCore.term cx input))),+                      (Core.Name "variable", (\input -> Eithers.map (\t -> Query.NodeVariable t) (variable cx input))),+                      (Core.Name "wildcard", (\input -> Eithers.map (\t -> Query.NodeWildcard) (ExtractCore.decodeUnit 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.query.Path+path :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Path+path 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 "step", (\input -> Eithers.map (\t -> Query.PathStep t) (step cx input))),+                      (Core.Name "regex", (\input -> Eithers.map (\t -> Query.PathRegex t) (regexSequence cx input))),+                      (Core.Name "inverse", (\input -> Eithers.map (\t -> Query.PathInverse t) (path 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.query.PathEquation+pathEquation :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.PathEquation+pathEquation cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "left" path fieldMap cx) (\field_left -> Eithers.bind (ExtractCore.requireField "right" path fieldMap cx) (\field_right -> Right (Query.PathEquation {+          Query.pathEquationLeft = field_left,+          Query.pathEquationRight = field_right}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.PathEquation")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.Pattern+pattern :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Pattern+pattern 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 "triple", (\input -> Eithers.map (\t -> Query.PatternTriple t) (triplePattern cx input))),+                      (Core.Name "negation", (\input -> Eithers.map (\t -> Query.PatternNegation t) (pattern cx input))),+                      (+                        Core.Name "conjunction",+                        (\input -> Eithers.map (\t -> Query.PatternConjunction t) (ExtractCore.decodeList pattern cx input))),+                      (+                        Core.Name "disjunction",+                        (\input -> Eithers.map (\t -> Query.PatternDisjunction t) (ExtractCore.decodeList pattern cx input))),+                      (Core.Name "graph", (\input -> Eithers.map (\t -> Query.PatternGraph t) (graphPattern 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.query.PatternImplication+patternImplication :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.PatternImplication+patternImplication cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "antecedent" pattern fieldMap cx) (\field_antecedent -> Eithers.bind (ExtractCore.requireField "consequent" pattern fieldMap cx) (\field_consequent -> Right (Query.PatternImplication {+          Query.patternImplicationAntecedent = field_antecedent,+          Query.patternImplicationConsequent = field_consequent}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.PatternImplication")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.Query+query :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Query+query cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "variables" (ExtractCore.decodeList variable) fieldMap cx) (\field_variables -> Eithers.bind (ExtractCore.requireField "patterns" (ExtractCore.decodeList pattern) fieldMap cx) (\field_patterns -> Right (Query.Query {+          Query.queryVariables = field_variables,+          Query.queryPatterns = field_patterns}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.Query")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.Range+range :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Range+range cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "min" (\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_min -> Eithers.bind (ExtractCore.requireField "max" (\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_max -> Right (Query.Range {+          Query.rangeMin = field_min,+          Query.rangeMax = field_max}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.Range")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.RegexQuantifier+regexQuantifier :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.RegexQuantifier+regexQuantifier 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 "one", (\input -> Eithers.map (\t -> Query.RegexQuantifierOne) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "zeroOrOne", (\input -> Eithers.map (\t -> Query.RegexQuantifierZeroOrOne) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "zeroOrMore",+                        (\input -> Eithers.map (\t -> Query.RegexQuantifierZeroOrMore) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "oneOrMore", (\input -> Eithers.map (\t -> Query.RegexQuantifierOneOrMore) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "exactly",+                        (\input -> Eithers.map (\t -> Query.RegexQuantifierExactly t) (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 cx input)))),+                      (+                        Core.Name "atLeast",+                        (\input -> Eithers.map (\t -> Query.RegexQuantifierAtLeast t) (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 cx input)))),+                      (Core.Name "range", (\input -> Eithers.map (\t -> Query.RegexQuantifierRange t) (range 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.query.RegexSequence+regexSequence :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.RegexSequence+regexSequence cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "path" path fieldMap cx) (\field_path -> Eithers.bind (ExtractCore.requireField "quantifier" regexQuantifier fieldMap cx) (\field_quantifier -> Right (Query.RegexSequence {+          Query.regexSequencePath = field_path,+          Query.regexSequenceQuantifier = field_quantifier}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.RegexSequence")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.Step+step :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Step+step 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 "edge", (\input -> Eithers.map (\t -> Query.StepEdge t) (edge cx input))),+                      (Core.Name "project", (\input -> Eithers.map (\t -> Query.StepProject t) (DecodeCore.projection cx input))),+                      (Core.Name "compare", (\input -> Eithers.map (\t -> Query.StepCompare t) (comparisonConstraint 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.query.TriplePattern+triplePattern :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.TriplePattern+triplePattern cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "subject" node fieldMap cx) (\field_subject -> Eithers.bind (ExtractCore.requireField "predicate" path fieldMap cx) (\field_predicate -> Eithers.bind (ExtractCore.requireField "object" node fieldMap cx) (\field_object -> Right (Query.TriplePattern {+          Query.triplePatternSubject = field_subject,+          Query.triplePatternPredicate = field_predicate,+          Query.triplePatternObject = field_object})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.query.TriplePattern")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.query.Variable+variable :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Query.Variable+variable cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Query.Variable b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Relational.hs view
@@ -0,0 +1,92 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.relational++module Hydra.Decode.Relational 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.Relational as Relational+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.relational.ColumnName+columnName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.ColumnName+columnName cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Relational.ColumnName b) ((\raw2 -> 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 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 t cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" columnName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "domain" t fieldMap cx) (\field_domain -> Right (Relational.ColumnSchema {+          Relational.columnSchemaName = field_name,+          Relational.columnSchemaDomain = field_domain}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.relational.ColumnSchema")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.relational.ForeignKey+foreignKey :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.ForeignKey+foreignKey cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "foreignRelation" relationName fieldMap cx) (\field_foreignRelation -> Eithers.bind (ExtractCore.requireField "keys" (ExtractCore.decodeMap columnName columnName) fieldMap cx) (\field_keys -> Right (Relational.ForeignKey {+          Relational.foreignKeyForeignRelation = field_foreignRelation,+          Relational.foreignKeyKeys = field_keys}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.relational.ForeignKey")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.relational.PrimaryKey+primaryKey :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.PrimaryKey+primaryKey cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      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 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))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.relational.RelationName+relationName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Relational.RelationName+relationName cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Relational.RelationName b) ((\raw2 -> 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 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 t cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" relationName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "columns" (ExtractCore.decodeList (columnSchema t)) fieldMap cx) (\field_columns -> Eithers.bind (ExtractCore.requireField "primaryKeys" (ExtractCore.decodeList primaryKey) fieldMap cx) (\field_primaryKeys -> Eithers.bind (ExtractCore.requireField "foreignKeys" (ExtractCore.decodeList foreignKey) fieldMap cx) (\field_foreignKeys -> Right (Relational.RelationSchema {+          Relational.relationSchemaName = field_name,+          Relational.relationSchemaColumns = field_columns,+          Relational.relationSchemaPrimaryKeys = field_primaryKeys,+          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 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 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))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Tabular.hs view
@@ -0,0 +1,63 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.tabular++module Hydra.Decode.Tabular where+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Relational as Relational+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.Tabular as Tabular+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.tabular.ColumnType+columnType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Tabular.ColumnType+columnType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" Relational.columnName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Right (Tabular.ColumnType {+          Tabular.columnTypeName = field_name,+          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 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))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.tabular.HeaderRow+headerRow :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Tabular.HeaderRow+headerRow cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Tabular.HeaderRow b) (ExtractCore.decodeList (\cx2 -> \raw2 -> 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 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 v cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "header" (ExtractCore.decodeMaybe headerRow) fieldMap cx) (\field_header -> Eithers.bind (ExtractCore.requireField "data" (ExtractCore.decodeList (dataRow v)) fieldMap cx) (\field_data -> Right (Tabular.Table {+          Tabular.tableHeader = field_header,+          Tabular.tableData = field_data}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.tabular.Table")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.tabular.TableType+tableType :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Tabular.TableType+tableType cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" Relational.relationName fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "columns" (ExtractCore.decodeList columnType) fieldMap cx) (\field_columns -> Right (Tabular.TableType {+          Tabular.tableTypeName = field_name,+          Tabular.tableTypeColumns = field_columns}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.tabular.TableType")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Testing.hs view
@@ -0,0 +1,26 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.testing++module Hydra.Decode.Testing 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.Rewriting as Rewriting+import qualified Hydra.Testing as Testing+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.testing.Tag+tag :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Testing.Tag+tag cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Testing.Tag b) ((\raw2 -> 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 raw2)) (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Topology.hs view
@@ -0,0 +1,62 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.topology++module Hydra.Decode.Topology 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.Rewriting as Rewriting+import qualified Hydra.Topology as Topology+import qualified Hydra.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+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 = ExtractCore.decodeMap vertex (ExtractCore.decodeList vertex)+-- | Decoder for hydra.topology.TarjanState+tarjanState :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Topology.TarjanState+tarjanState cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "counter" (\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_counter -> Eithers.bind (ExtractCore.requireField "indices" (ExtractCore.decodeMap vertex (\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_indices -> Eithers.bind (ExtractCore.requireField "lowLinks" (ExtractCore.decodeMap vertex (\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_lowLinks -> Eithers.bind (ExtractCore.requireField "stack" (ExtractCore.decodeList vertex) fieldMap cx) (\field_stack -> Eithers.bind (ExtractCore.requireField "onStack" (ExtractCore.decodeSet vertex) fieldMap cx) (\field_onStack -> Eithers.bind (ExtractCore.requireField "sccs" (ExtractCore.decodeList (ExtractCore.decodeList vertex)) fieldMap cx) (\field_sccs -> Right (Topology.TarjanState {+          Topology.tarjanStateCounter = field_counter,+          Topology.tarjanStateIndices = field_indices,+          Topology.tarjanStateLowLinks = field_lowLinks,+          Topology.tarjanStateStack = field_stack,+          Topology.tarjanStateOnStack = field_onStack,+          Topology.tarjanStateSccs = field_sccs}))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.topology.TarjanState")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.topology.Vertex+vertex :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Int+vertex cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermLiteral v0 -> case v0 of+        Core.LiteralInteger v1 -> case v1 of+          Core.IntegerValueInt32 v2 -> Right v2+          _ -> Left (Errors.DecodingError "expected int32 value")+        _ -> Left (Errors.DecodingError "expected int32 literal")+      _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Typed.hs view
@@ -0,0 +1,42 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.typed++module Hydra.Decode.Typed 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.Rewriting as Rewriting+import qualified Hydra.Typed as Typed+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.typed.TypedBinding+typedBinding :: t0 -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typed.TypedBinding t1)+typedBinding a cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "term" (typedTerm a) fieldMap cx) (\field_term -> Right (Typed.TypedBinding {+          Typed.typedBindingName = field_name,+          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 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 a cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "term" (typedTerm a) fieldMap cx) (\field_term -> Right (Typed.TypedTermDefinition {+          Typed.typedTermDefinitionName = field_name,+          Typed.typedTermDefinitionTerm = field_term}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typed.TypedTermDefinition")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Typing.hs view
@@ -0,0 +1,156 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.typing++module Hydra.Decode.Typing where+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Paths as Paths+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.Typing as Typing+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.typing.FunctionStructure+functionStructure :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Typing.FunctionStructure t0)+functionStructure env cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "typeParams" (ExtractCore.decodeList DecodeCore.name) fieldMap cx) (\field_typeParams -> Eithers.bind (ExtractCore.requireField "params" (ExtractCore.decodeList DecodeCore.name) fieldMap cx) (\field_params -> Eithers.bind (ExtractCore.requireField "bindings" (ExtractCore.decodeList DecodeCore.binding) fieldMap cx) (\field_bindings -> Eithers.bind (ExtractCore.requireField "body" DecodeCore.term fieldMap cx) (\field_body -> Eithers.bind (ExtractCore.requireField "domains" (ExtractCore.decodeList DecodeCore.type_) fieldMap cx) (\field_domains -> Eithers.bind (ExtractCore.requireField "codomain" (ExtractCore.decodeMaybe DecodeCore.type_) fieldMap cx) (\field_codomain -> Eithers.bind (ExtractCore.requireField "environment" env fieldMap cx) (\field_environment -> Right (Typing.FunctionStructure {+          Typing.functionStructureTypeParams = field_typeParams,+          Typing.functionStructureParams = field_params,+          Typing.functionStructureBindings = field_bindings,+          Typing.functionStructureBody = field_body,+          Typing.functionStructureDomains = field_domains,+          Typing.functionStructureCodomain = field_codomain,+          Typing.functionStructureEnvironment = field_environment})))))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.FunctionStructure")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.InferenceContext+inferenceContext :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.InferenceContext+inferenceContext cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "freshTypeVariableCount" (\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_freshTypeVariableCount -> Eithers.bind (ExtractCore.requireField "trace" (ExtractCore.decodeList Paths.subtermStep) fieldMap cx) (\field_trace -> Right (Typing.InferenceContext {+          Typing.inferenceContextFreshTypeVariableCount = field_freshTypeVariableCount,+          Typing.inferenceContextTrace = field_trace}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.InferenceContext")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.InferenceResult+inferenceResult :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.InferenceResult+inferenceResult cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "term" DecodeCore.term fieldMap cx) (\field_term -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "subst" typeSubst fieldMap cx) (\field_subst -> Eithers.bind (ExtractCore.requireField "classConstraints" (ExtractCore.decodeMap DecodeCore.name DecodeCore.typeVariableConstraints) fieldMap cx) (\field_classConstraints -> Eithers.bind (ExtractCore.requireField "context" inferenceContext fieldMap cx) (\field_context -> Right (Typing.InferenceResult {+          Typing.inferenceResultTerm = field_term,+          Typing.inferenceResultType = field_type,+          Typing.inferenceResultSubst = field_subst,+          Typing.inferenceResultClassConstraints = field_classConstraints,+          Typing.inferenceResultContext = field_context})))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.InferenceResult")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.Parameter+parameter :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.Parameter+parameter cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "description" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> 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 cx2 raw2))) fieldMap cx) (\field_description -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Eithers.bind (ExtractCore.requireField "isLazy" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_isLazy -> Right (Typing.Parameter {+          Typing.parameterName = field_name,+          Typing.parameterDescription = field_description,+          Typing.parameterType = field_type,+          Typing.parameterIsLazy = field_isLazy}))))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.Parameter")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.Result+result :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.Result+result cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "description" (ExtractCore.decodeMaybe (\cx2 -> \raw2 -> 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 cx2 raw2))) fieldMap cx) (\field_description -> Eithers.bind (ExtractCore.requireField "type" DecodeCore.type_ fieldMap cx) (\field_type -> Right (Typing.Result {+          Typing.resultDescription = field_description,+          Typing.resultType = field_type}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.Result")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.TermSignature+termSignature :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TermSignature+termSignature cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "typeParameters" (ExtractCore.decodeList typeParameter) fieldMap cx) (\field_typeParameters -> Eithers.bind (ExtractCore.requireField "parameters" (ExtractCore.decodeList parameter) fieldMap cx) (\field_parameters -> Eithers.bind (ExtractCore.requireField "result" result fieldMap cx) (\field_result -> Right (Typing.TermSignature {+          Typing.termSignatureTypeParameters = field_typeParameters,+          Typing.termSignatureParameters = field_parameters,+          Typing.termSignatureResult = field_result})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.TermSignature")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.TermSubst+termSubst :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TermSubst+termSubst cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Typing.TermSubst b) (ExtractCore.decodeMap DecodeCore.name DecodeCore.term cx (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.TypeClass+typeClass :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TypeClass+typeClass cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "description" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_description -> Right (Typing.TypeClass {+          Typing.typeClassDescription = field_description})))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.TypeClass")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.TypeConstraint+typeConstraint :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TypeConstraint+typeConstraint cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "left" DecodeCore.type_ fieldMap cx) (\field_left -> Eithers.bind (ExtractCore.requireField "right" DecodeCore.type_ fieldMap cx) (\field_right -> Eithers.bind (ExtractCore.requireField "comment" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_comment -> Right (Typing.TypeConstraint {+          Typing.typeConstraintLeft = field_left,+          Typing.typeConstraintRight = field_right,+          Typing.typeConstraintComment = field_comment})))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.TypeConstraint")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.TypeParameter+typeParameter :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TypeParameter+typeParameter cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "name" DecodeCore.name fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "constraints" (ExtractCore.decodeList DecodeCore.typeClassConstraint) fieldMap cx) (\field_constraints -> Right (Typing.TypeParameter {+          Typing.typeParameterName = field_name,+          Typing.typeParameterConstraints = field_constraints}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.typing.TypeParameter")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.typing.TypeSubst+typeSubst :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Typing.TypeSubst+typeSubst cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Typing.TypeSubst b) (ExtractCore.decodeMap DecodeCore.name DecodeCore.type_ cx (Core.wrappedTermBody v0))+      _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Util.hs view
@@ -0,0 +1,115 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.util++module Hydra.Decode.Util where+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Decode.Packaging as Packaging+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.util.CaseConvention+caseConvention :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.CaseConvention+caseConvention 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 "camel", (\input -> Eithers.map (\t -> Util.CaseConventionCamel) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "pascal", (\input -> Eithers.map (\t -> Util.CaseConventionPascal) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "lowerSnake", (\input -> Eithers.map (\t -> Util.CaseConventionLowerSnake) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "upperSnake", (\input -> Eithers.map (\t -> Util.CaseConventionUpperSnake) (ExtractCore.decodeUnit 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.util.Comparison+comparison :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.Comparison+comparison 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 "lessThan", (\input -> Eithers.map (\t -> Util.ComparisonLessThan) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "equalTo", (\input -> Eithers.map (\t -> Util.ComparisonEqualTo) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "greaterThan", (\input -> Eithers.map (\t -> Util.ComparisonGreaterThan) (ExtractCore.decodeUnit 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.util.FileExtension+fileExtension :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.FileExtension+fileExtension cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermWrap v0 -> Eithers.map (\b -> Util.FileExtension b) ((\raw2 -> 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 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 n cx raw =+    Eithers.either (\err -> Left err) (\stripped -> case stripped of+      Core.TermRecord v0 ->+        let fieldMap = ExtractCore.toFieldMap v0+        in (Eithers.bind (ExtractCore.requireField "focus" (ExtractCore.decodePair Packaging.moduleName n) fieldMap cx) (\field_focus -> Eithers.bind (ExtractCore.requireField "mapping" (ExtractCore.decodeMap Packaging.moduleName n) fieldMap cx) (\field_mapping -> Right (Util.ModuleNames {+          Util.moduleNamesFocus = field_focus,+          Util.moduleNamesMapping = field_mapping}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.util.ModuleNames")) (ExtractCore.stripWithDecodingError cx raw)+-- | Decoder for hydra.util.Precision+precision :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.Precision+precision 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 "arbitrary", (\input -> Eithers.map (\t -> Util.PrecisionArbitrary) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "bits",+                        (\input -> Eithers.map (\t -> Util.PrecisionBits t) (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 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.util.QualifiedName+qualifiedName :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Util.QualifiedName+qualifiedName 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" (ExtractCore.decodeMaybe Packaging.moduleName) fieldMap cx) (\field_moduleName -> Eithers.bind (ExtractCore.requireField "local" (\cx2 -> \raw2 -> 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 cx2 raw2)) fieldMap cx) (\field_local -> Right (Util.QualifiedName {+          Util.qualifiedNameModuleName = field_moduleName,+          Util.qualifiedNameLocal = field_local}))))+      _ -> Left (Errors.DecodingError "expected a record of type hydra.util.QualifiedName")) (ExtractCore.stripWithDecodingError cx raw)
+ src/main/haskell/Hydra/Decode/Variants.hs view
@@ -0,0 +1,114 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term decoders for hydra.variants++module Hydra.Decode.Variants 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.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Decoder for hydra.variants.LiteralVariant+literalVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.LiteralVariant+literalVariant 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 "binary", (\input -> Eithers.map (\t -> Variants.LiteralVariantBinary) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "boolean", (\input -> Eithers.map (\t -> Variants.LiteralVariantBoolean) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "decimal", (\input -> Eithers.map (\t -> Variants.LiteralVariantDecimal) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "float", (\input -> Eithers.map (\t -> Variants.LiteralVariantFloat) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "integer", (\input -> Eithers.map (\t -> Variants.LiteralVariantInteger) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "string", (\input -> Eithers.map (\t -> Variants.LiteralVariantString) (ExtractCore.decodeUnit 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.variants.TermVariant+termVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.TermVariant+termVariant 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 "annotated", (\input -> Eithers.map (\t -> Variants.TermVariantAnnotated) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "application",+                        (\input -> Eithers.map (\t -> Variants.TermVariantApplication) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "cases", (\input -> Eithers.map (\t -> Variants.TermVariantCases) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "either", (\input -> Eithers.map (\t -> Variants.TermVariantEither) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "inject", (\input -> Eithers.map (\t -> Variants.TermVariantInject) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "lambda", (\input -> Eithers.map (\t -> Variants.TermVariantLambda) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "let", (\input -> Eithers.map (\t -> Variants.TermVariantLet) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "list", (\input -> Eithers.map (\t -> Variants.TermVariantList) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "literal", (\input -> Eithers.map (\t -> Variants.TermVariantLiteral) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "map", (\input -> Eithers.map (\t -> Variants.TermVariantMap) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "optional", (\input -> Eithers.map (\t -> Variants.TermVariantOptional) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "pair", (\input -> Eithers.map (\t -> Variants.TermVariantPair) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "project", (\input -> Eithers.map (\t -> Variants.TermVariantProject) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "record", (\input -> Eithers.map (\t -> Variants.TermVariantRecord) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "set", (\input -> Eithers.map (\t -> Variants.TermVariantSet) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "typeApplication",+                        (\input -> Eithers.map (\t -> Variants.TermVariantTypeApplication) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "typeLambda", (\input -> Eithers.map (\t -> Variants.TermVariantTypeLambda) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "unit", (\input -> Eithers.map (\t -> Variants.TermVariantUnit) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "unwrap", (\input -> Eithers.map (\t -> Variants.TermVariantUnwrap) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "variable", (\input -> Eithers.map (\t -> Variants.TermVariantVariable) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "wrap", (\input -> Eithers.map (\t -> Variants.TermVariantWrap) (ExtractCore.decodeUnit 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.variants.TypeVariant+typeVariant :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Variants.TypeVariant+typeVariant 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 "annotated", (\input -> Eithers.map (\t -> Variants.TypeVariantAnnotated) (ExtractCore.decodeUnit cx input))),+                      (+                        Core.Name "application",+                        (\input -> Eithers.map (\t -> Variants.TypeVariantApplication) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "either", (\input -> Eithers.map (\t -> Variants.TypeVariantEither) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "forall", (\input -> Eithers.map (\t -> Variants.TypeVariantForall) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "function", (\input -> Eithers.map (\t -> Variants.TypeVariantFunction) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "list", (\input -> Eithers.map (\t -> Variants.TypeVariantList) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "literal", (\input -> Eithers.map (\t -> Variants.TypeVariantLiteral) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "map", (\input -> Eithers.map (\t -> Variants.TypeVariantMap) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "optional", (\input -> Eithers.map (\t -> Variants.TypeVariantOptional) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "pair", (\input -> Eithers.map (\t -> Variants.TypeVariantPair) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "record", (\input -> Eithers.map (\t -> Variants.TypeVariantRecord) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "set", (\input -> Eithers.map (\t -> Variants.TypeVariantSet) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "union", (\input -> Eithers.map (\t -> Variants.TypeVariantUnion) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "unit", (\input -> Eithers.map (\t -> Variants.TypeVariantUnit) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "variable", (\input -> Eithers.map (\t -> Variants.TypeVariantVariable) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "void", (\input -> Eithers.map (\t -> Variants.TypeVariantVoid) (ExtractCore.decodeUnit cx input))),+                      (Core.Name "wrap", (\input -> Eithers.map (\t -> Variants.TypeVariantWrap) (ExtractCore.decodeUnit 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)
+ src/main/haskell/Hydra/Decoding.hs view
@@ -0,0 +1,1640 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Functions for generating term decoders from type modules++module Hydra.Decoding where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Extract.Core as ExtractCore+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Predicates as Predicates+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Collect forall type variable names from a type+collectForallVariables :: Core.Type -> [Core.Name]+collectForallVariables typ =+    case typ of+      Core.TypeAnnotated v0 -> collectForallVariables (Core.annotatedTypeBody v0)+      Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (collectForallVariables (Core.forallTypeBody v0))+      _ -> []+-- | Collect type variables needing Ord constraints (from Map key and Set element types)+collectOrdConstrainedVariables :: Core.Type -> [Core.Name]+collectOrdConstrainedVariables typ =+    case typ of+      Core.TypeAnnotated v0 -> collectOrdConstrainedVariables (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Lists.concat2 (collectOrdConstrainedVariables (Core.applicationTypeFunction v0)) (collectOrdConstrainedVariables (Core.applicationTypeArgument v0))+      Core.TypeEither v0 -> Lists.concat2 (collectOrdConstrainedVariables (Core.eitherTypeLeft v0)) (collectOrdConstrainedVariables (Core.eitherTypeRight v0))+      Core.TypeForall v0 -> collectOrdConstrainedVariables (Core.forallTypeBody v0)+      Core.TypeList v0 -> collectOrdConstrainedVariables v0+      Core.TypeMap v0 -> Lists.concat [+        collectTypeVariablesFromType (Core.mapTypeKeys v0),+        (collectOrdConstrainedVariables (Core.mapTypeKeys v0)),+        (collectOrdConstrainedVariables (Core.mapTypeValues v0))]+      Core.TypeOptional v0 -> collectOrdConstrainedVariables v0+      Core.TypePair v0 -> Lists.concat2 (collectOrdConstrainedVariables (Core.pairTypeFirst v0)) (collectOrdConstrainedVariables (Core.pairTypeSecond v0))+      Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> collectOrdConstrainedVariables (Core.fieldTypeType ft)) v0)+      Core.TypeSet v0 -> Lists.concat2 (collectTypeVariablesFromType v0) (collectOrdConstrainedVariables v0)+      Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> collectOrdConstrainedVariables (Core.fieldTypeType ft)) v0)+      Core.TypeWrap v0 -> collectOrdConstrainedVariables v0+      _ -> []+-- | Collect type variable names from a type (forall parameters only)+collectTypeVariables :: Core.Type -> [Core.Name]+collectTypeVariables typ = collectForallVariables typ+-- | Collect all type variable names from a type expression+collectTypeVariablesFromType :: Core.Type -> [Core.Name]+collectTypeVariablesFromType typ =+    case typ of+      Core.TypeAnnotated v0 -> collectTypeVariablesFromType (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.applicationTypeFunction v0)) (collectTypeVariablesFromType (Core.applicationTypeArgument v0))+      Core.TypeEither v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.eitherTypeLeft v0)) (collectTypeVariablesFromType (Core.eitherTypeRight v0))+      Core.TypeForall v0 -> collectTypeVariablesFromType (Core.forallTypeBody v0)+      Core.TypeList v0 -> collectTypeVariablesFromType v0+      Core.TypeMap v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.mapTypeKeys v0)) (collectTypeVariablesFromType (Core.mapTypeValues v0))+      Core.TypeOptional v0 -> collectTypeVariablesFromType v0+      Core.TypePair v0 -> Lists.concat2 (collectTypeVariablesFromType (Core.pairTypeFirst v0)) (collectTypeVariablesFromType (Core.pairTypeSecond v0))+      Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> collectTypeVariablesFromType (Core.fieldTypeType ft)) v0)+      Core.TypeSet v0 -> collectTypeVariablesFromType v0+      Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> collectTypeVariablesFromType (Core.fieldTypeType ft)) v0)+      Core.TypeVariable v0 -> [+        v0]+      Core.TypeWrap v0 -> collectTypeVariablesFromType v0+      _ -> []+-- | Transform a type binding into a decoder binding+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")+      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.TypeSet v0 -> Core.TypeSet (decoderFullResultType v0)+      Core.TypeUnit -> Core.TypeUnit+      Core.TypeVariable v0 -> Core.TypeVariable v0+      Core.TypeVoid -> Core.TypeVoid+      _ -> Core.TypeVariable (Core.Name "hydra.core.Term")+-- | Compute the result type name for a decoder+decoderResultType :: Core.Type -> Core.Name+decoderResultType typ =+    case typ of+      Core.TypeAnnotated v0 -> decoderResultType (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> decoderResultType (Core.applicationTypeFunction v0)+      Core.TypeForall v0 -> decoderResultType (Core.forallTypeBody v0)+      Core.TypeLiteral _ -> Core.Name "hydra.core.Literal"+      Core.TypeRecord _ -> Core.Name "hydra.core.Term"+      Core.TypeUnion _ -> Core.Name "hydra.core.Term"+      Core.TypeWrap _ -> Core.Name "hydra.core.Term"+      _ -> Core.Name "hydra.core.Term"+-- | Build decoder function type+decoderType :: Core.Type -> Core.Type+decoderType typ =++      let resultType = decoderFullResultType typ+          baseType =+                  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 = resultType}))}))})+      in (prependForallDecoders baseType typ)+-- | Build decoder function type with element name+decoderTypeNamed :: Core.Name -> Core.Type -> Core.Type+decoderTypeNamed ename typ =++      let resultType = decoderFullResultTypeNamed ename typ+          baseType =+                  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 = resultType}))}))})+      in (prependForallDecoders baseType typ)+-- | Build type scheme for a decoder function+decoderTypeScheme :: Core.Type -> Core.TypeScheme+decoderTypeScheme typ =++      let typeVars = collectTypeVariables typ+          allOrdVars = collectOrdConstrainedVariables typ+          ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars+          constraints =+                  Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (+                    v,+                    Core.TypeVariableConstraints {+                      Core.typeVariableConstraintsClasses = [+                        Core.TypeClassConstraintSimple (Core.Name "ordering")]})) ordVars)))+      in Core.TypeScheme {+        Core.typeSchemeVariables = typeVars,+        Core.typeSchemeBody = (decoderType typ),+        Core.typeSchemeConstraints = constraints}+-- | Build type scheme for a decoder function with element name+decoderTypeSchemeNamed :: Core.Name -> Core.Type -> Core.TypeScheme+decoderTypeSchemeNamed ename typ =++      let typeVars = collectTypeVariables typ+          allOrdVars = collectOrdConstrainedVariables typ+          ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars+          constraints =+                  Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (+                    v,+                    Core.TypeVariableConstraints {+                      Core.typeVariableConstraintsClasses = [+                        Core.TypeClassConstraintSimple (Core.Name "ordering")]})) ordVars)))+      in Core.TypeScheme {+        Core.typeSchemeVariables = typeVars,+        Core.typeSchemeBody = (decoderTypeNamed ename typ),+        Core.typeSchemeConstraints = constraints}+-- | Filter bindings to only decodable type definitions+filterTypeBindings :: t0 -> Graph.Graph -> [Core.Binding] -> Either Errors.Error [Core.Binding]+filterTypeBindings cx graph bindings =+    Eithers.map Optionals.cat (Eithers.mapList (isDecodableBinding cx graph) (Lists.filter Annotations.isNativeType bindings))+-- | Check if a binding is decodable (serializable type)+isDecodableBinding :: t0 -> Graph.Graph -> Core.Binding -> Either Errors.Error (Maybe Core.Binding)+isDecodableBinding cx graph b =+    Eithers.bind (Predicates.isSerializableByName cx graph (Core.bindingName b)) (\serializable -> Right (Logic.ifElse serializable (Just b) Nothing))+-- | Prepend decoder types for forall parameters to base type+prependForallDecoders :: Core.Type -> Core.Type -> Core.Type+prependForallDecoders baseType typ =+    case typ of+      Core.TypeAnnotated v0 -> prependForallDecoders baseType (Core.annotatedTypeBody v0)+      Core.TypeForall v0 -> Core.TypeFunction (Core.FunctionType {+        Core.functionTypeDomain = (Core.TypeFunction (Core.FunctionType {+          Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+          Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+            Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+            Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.forallTypeParameter v0))}))}))})),+        Core.functionTypeCodomain = (prependForallDecoders baseType (Core.forallTypeBody v0))})+      _ -> baseType
+ src/main/haskell/Hydra/Dependencies.hs view
@@ -0,0 +1,333 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Dependency extraction, binding sort, and let normalization++module Hydra.Dependencies where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Get definitions with their dependencies+definitionsWithDependencies :: t0 -> Graph.Graph -> [Core.Binding] -> Either Errors.Error [Core.Binding]+definitionsWithDependencies cx graph original =++      let depNames = \el -> Sets.toList (termDependencyNames True False False (Core.bindingTerm el))+          allDepNames = Lists.nub (Lists.concat2 (Lists.map Core.bindingName original) (Lists.concat (Lists.map depNames original)))+      in (Eithers.mapList (\name -> Lexical.requireBinding graph name) allDepNames)+-- | Flatten nested let expressions+flattenLetTerms :: Core.Term -> Core.Term+flattenLetTerms term =++      let rewriteBinding =+              \binding ->+                let key0 = Core.bindingName binding+                    val0 = Core.bindingTerm binding+                    t = Core.bindingTypeScheme binding+                in case val0 of+                  Core.TermAnnotated v0 ->+                    let val1 = Core.annotatedTermBody v0+                        ann = Core.annotatedTermAnnotation v0+                        recursive =+                                rewriteBinding (Core.Binding {+                                  Core.bindingName = key0,+                                  Core.bindingTerm = val1,+                                  Core.bindingTypeScheme = t})+                        innerBinding = Pairs.first recursive+                        deps = Pairs.second recursive+                        val2 = Core.bindingTerm innerBinding+                    in (+                      Core.Binding {+                        Core.bindingName = key0,+                        Core.bindingTerm = (Core.TermAnnotated (Core.AnnotatedTerm {+                          Core.annotatedTermBody = val2,+                          Core.annotatedTermAnnotation = ann})),+                        Core.bindingTypeScheme = t},+                      deps)+                  Core.TermLet v0 ->+                    let bindings1 = Core.letBindings v0+                        body1 = Core.letBody v0+                        prefix = Strings.cat2 (Core.unName key0) "_"+                        qualify = \n -> Core.Name (Strings.cat2 prefix (Core.unName n))+                        toSubstPair = \b -> (Core.bindingName b, (qualify (Core.bindingName b)))+                        subst = Maps.fromList (Lists.map toSubstPair bindings1)+                        replaceVars = Variables.substituteVariables subst+                        newBody = replaceVars body1+                        newBinding =+                                \b -> Core.Binding {+                                  Core.bindingName = (qualify (Core.bindingName b)),+                                  Core.bindingTerm = (replaceVars (Core.bindingTerm b)),+                                  Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                    in (+                      Core.Binding {+                        Core.bindingName = key0,+                        Core.bindingTerm = newBody,+                        Core.bindingTypeScheme = t},+                      (Lists.map newBinding bindings1))+                  _ -> (+                    Core.Binding {+                      Core.bindingName = key0,+                      Core.bindingTerm = val0,+                      Core.bindingTypeScheme = t},+                    [])+          flattenBodyLet =+                  \bindings -> \body -> case body of+                    Core.TermLet v0 ->+                      let innerBindings = Core.letBindings v0+                          innerBody = Core.letBody v0+                      in (flattenBodyLet (Lists.concat2 bindings innerBindings) innerBody)+                    _ -> (Lists.concat2 [] bindings, body)+          flatten =+                  \recurse -> \term2 ->+                    let rewritten = recurse term2+                    in case rewritten of+                      Core.TermLet v0 ->+                        let bindings = Core.letBindings v0+                            body = Core.letBody v0+                            forResult = \hr -> Lists.concat2 (Pairs.second hr) (Lists.pure (Pairs.first hr))+                            flattenedBindings = Lists.concat (Lists.map (\arg_ -> forResult (rewriteBinding arg_)) bindings)+                            merged = flattenBodyLet flattenedBindings body+                            newBindings = Pairs.first merged+                            newBody = Pairs.second merged+                        in (Core.TermLet (Core.Let {+                          Core.letBindings = newBindings,+                          Core.letBody = newBody}))+                      _ -> rewritten+      in (Rewriting.rewriteTerm flatten term)+-- | Inline all type variables in a type using the provided schema (Either version). Note: this function is only appropriate for nonrecursive type definitions+inlineType :: M.Map Core.Name Core.Type -> Core.Type -> Either Errors.Error Core.Type+inlineType schema typ =++      let f =+              \recurse -> \typ2 ->+                let afterRecurse =+                        \tr -> case tr of+                          Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 schema) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "No such type in schema: " (Core.unName v0))))) (inlineType schema)+                          _ -> Right tr+                in (Eithers.bind (recurse typ2) (\tr -> afterRecurse tr))+      in (Rewriting.rewriteTypeM f typ)+-- | Check whether a term is a lambda, possibly nested within let and/or annotation terms+isLambda :: Core.Term -> Bool+isLambda term =+    case (Strip.deannotateTerm term) of+      Core.TermLambda _ -> True+      Core.TermLet v0 -> isLambda (Core.letBody v0)+      _ -> False+-- | Rewrite terms like `let foo = bar in λx.baz` to `λx.let foo = bar in baz`, lifting lambda-bound variables above let-bound variables, recursively. This is helpful for targets such as Python.+liftLambdaAboveLet :: Core.Term -> Core.Term+liftLambdaAboveLet term0 =++      let rewrite =+              \recurse -> \term ->+                let rewriteBinding =+                        \b -> Core.Binding {+                          Core.bindingName = (Core.bindingName b),+                          Core.bindingTerm = (rewrite recurse (Core.bindingTerm b)),+                          Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                    rewriteBindings = \bs -> Lists.map rewriteBinding bs+                    digForLambdas =+                            \original -> \cons -> \term2 -> case term2 of+                              Core.TermAnnotated v0 -> digForLambdas original (\t -> Core.TermAnnotated (Core.AnnotatedTerm {+                                Core.annotatedTermBody = (cons t),+                                Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})) (Core.annotatedTermBody v0)+                              Core.TermLambda v0 -> Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.lambdaParameter v0),+                                Core.lambdaDomain = (Core.lambdaDomain v0),+                                Core.lambdaBody = (digForLambdas (cons (Core.lambdaBody v0)) (\t -> cons t) (Core.lambdaBody v0))})+                              Core.TermLet v0 -> digForLambdas original (\t -> cons (Core.TermLet (Core.Let {+                                Core.letBindings = (rewriteBindings (Core.letBindings v0)),+                                Core.letBody = t}))) (Core.letBody v0)+                              _ -> recurse original+                in case term of+                  Core.TermLet v0 -> digForLambdas term (\t -> Core.TermLet (Core.Let {+                    Core.letBindings = (rewriteBindings (Core.letBindings v0)),+                    Core.letBody = t})) (Core.letBody v0)+                  _ -> recurse term+      in (Rewriting.rewriteTerm rewrite term0)+-- | Given a let expression, remove any unused bindings. The resulting expression is still a let, even if has no remaining bindings+pruneLet :: Core.Let -> Core.Let+pruneLet l =++      let bindingMap = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) (Core.letBindings l))+          rootName = Core.Name "[[[root]]]"+          adj =+                  \n -> Sets.intersection (Sets.fromList (Maps.keys bindingMap)) (Variables.freeVariablesInTerm (Logic.ifElse (Equality.equal n rootName) (Core.letBody l) (Optionals.fromOptional Core.TermUnit (Maps.lookup n bindingMap))))+          reachable = Sorting.findReachableNodes adj rootName+          prunedBindings = Lists.filter (\b -> Sets.member (Core.bindingName b) reachable) (Core.letBindings l)+      in Core.Let {+        Core.letBindings = prunedBindings,+        Core.letBody = (Core.letBody l)}+-- | Replace all occurrences of simple typedefs (type aliases) with the aliased types, recursively+replaceTypedefs :: M.Map Core.Name Core.TypeScheme -> Core.Type -> Core.Type+replaceTypedefs types typ0 =++      let rewrite =+              \recurse -> \typ -> case typ of+                Core.TypeAnnotated v0 -> Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (rewrite recurse (Core.annotatedTypeBody v0)),+                  Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)})+                Core.TypeRecord _ -> typ+                Core.TypeUnion _ -> typ+                Core.TypeVariable v0 ->+                  let forMono =+                          \t -> case t of+                            Core.TypeRecord _ -> typ+                            Core.TypeUnion _ -> typ+                            Core.TypeWrap _ -> typ+                            _ -> rewrite recurse t+                      forTypeScheme =+                              \ts ->+                                let t = Core.typeSchemeBody ts+                                in (Logic.ifElse (Lists.null (Core.typeSchemeVariables ts)) (forMono t) typ)+                  in (Optionals.cases (Maps.lookup v0 types) typ (\ts -> forTypeScheme ts))+                Core.TypeWrap _ -> typ+                _ -> recurse typ+      in (Rewriting.rewriteType rewrite typ0)+-- | Simplify terms by applying beta reduction where possible+simplifyTerm :: Core.Term -> Core.Term+simplifyTerm term =++      let simplify =+              \recurse -> \term2 ->+                let forRhs =+                        \rhs -> \var -> \body -> case (Strip.deannotateTerm rhs) of+                          Core.TermVariable v0 -> simplifyTerm (Variables.substituteVariable var v0 body)+                          _ -> term2+                    forLhs =+                            \lhs -> \rhs -> case (Strip.deannotateTerm lhs) of+                              Core.TermLambda v0 ->+                                let var = Core.lambdaParameter v0+                                    body = Core.lambdaBody v0+                                in (Logic.ifElse (Sets.member var (Variables.freeVariablesInTerm body)) (forRhs rhs var body) (simplifyTerm body))+                              _ -> term2+                    forTerm =+                            \stripped -> case stripped of+                              Core.TermApplication v0 ->+                                let lhs = Core.applicationFunction v0+                                    rhs = Core.applicationArgument v0+                                in (forLhs lhs rhs)+                              _ -> term2+                    stripped = Strip.deannotateTerm term2+                in (recurse (forTerm stripped))+      in (Rewriting.rewriteTerm simplify term)+-- | Note: does not distinguish between bound and free variables; use freeVariablesInTerm for that+termDependencyNames :: Bool -> Bool -> Bool -> Core.Term -> S.Set Core.Name+termDependencyNames binds withPrims withNoms term0 =++      let addNames =+              \names -> \term ->+                let nominal = \name -> Logic.ifElse withNoms (Sets.insert name names) names+                    prim = \name -> Logic.ifElse withPrims (Sets.insert name names) names+                    var = \name -> Logic.ifElse binds (Sets.insert name names) names+                in case term of+                  Core.TermCases v0 -> nominal (Core.caseStatementTypeName v0)+                  Core.TermProject v0 -> nominal (Core.projectionTypeName v0)+                  Core.TermUnwrap v0 -> nominal v0+                  Core.TermRecord v0 -> nominal (Core.recordTypeName v0)+                  Core.TermInject v0 -> nominal (Core.injectionTypeName v0)+                  Core.TermVariable v0 -> var v0+                  Core.TermWrap v0 -> nominal (Core.wrappedTermTypeName v0)+                  _ -> names+      in (Rewriting.foldOverTerm Coders.TraversalOrderPre addNames Sets.empty term0)+-- | Generate short names from a list of fully qualified names+toShortNames :: [Core.Name] -> M.Map Core.Name Core.Name+toShortNames original =++      let addName =+              \acc -> \name ->+                let local = Names.localNameOf name+                    group = Optionals.fromOptional Sets.empty (Maps.lookup local acc)+                in (Maps.insert local (Sets.insert name group) acc)+          groupNamesByLocal = \names -> Lists.foldl addName Maps.empty names+          groups = groupNamesByLocal original+          renameGroup =+                  \localNames ->+                    let local = Pairs.first localNames+                        names = Pairs.second localNames+                        rangeFrom = \start -> Lists.cons start (rangeFrom (Math.add start 1))+                        rename =+                                \name -> \i -> (name, (Core.Name (Logic.ifElse (Equality.gt i 1) (Strings.cat2 local (Literals.showInt32 i)) local)))+                    in (Lists.zipWith rename (Sets.toList names) (rangeFrom 1))+      in (Maps.fromList (Lists.concat (Lists.map renameGroup (Maps.toList groups))))+-- | Topological sort of connected components, in terms of dependencies between variable/term binding pairs. The SCC partitioning is what makes the result usable as an emission order in every target language: non-recursive bindings emit in dependency order, while a mutually recursive cluster is delivered together so the emitter can wrap it in whatever construct the host requires (mutual `let`s, joint class files, forward declarations).+topologicalSortBindingMap :: M.Map Core.Name Core.Term -> [[(Core.Name, Core.Term)]]+topologicalSortBindingMap bindingMap =++      let bindings = Maps.toList bindingMap+          keys = Sets.fromList (Lists.map Pairs.first bindings)+          hasTypeAnnotation =+                  \term -> case term of+                    Core.TermAnnotated v0 -> hasTypeAnnotation (Core.annotatedTermBody v0)+                    _ -> False+          depsOf =+                  \nameAndTerm ->+                    let name = Pairs.first nameAndTerm+                        term = Pairs.second nameAndTerm+                    in (name, (Logic.ifElse (hasTypeAnnotation term) [] (Sets.toList (Sets.intersection keys (Variables.freeVariablesInTerm term)))))+          toPair =+                  \name -> (name, (Optionals.fromOptional (Core.TermLiteral (Core.LiteralString "Impossible!")) (Maps.lookup name bindingMap)))+      in (Lists.map (Lists.map toPair) (Sorting.topologicalSortComponents (Lists.map depsOf bindings)))+-- | Topological sort of bindings based on their dependencies. Returns `Right` with a flat order when the dependency graph is acyclic; returns `Left` with the cyclic SCCs when it is not. Use this variant when the consumer needs a strict acyclic ordering and must reject cycles (e.g. import resolution); use `topologicalSortBindingMap` when mutual recursion should be packaged into SCC groups instead.+topologicalSortBindings :: [Core.Binding] -> Either [[Core.Name]] [Core.Name]+topologicalSortBindings els =++      let adjlist = \e -> (Core.bindingName e, (Sets.toList (termDependencyNames False True True (Core.bindingTerm e))))+      in (Sorting.topologicalSort (Lists.map adjlist els))+-- | Topologically sort type definitions by their structural dependencies, grouped into SCCs. The SCC grouping handles mutually recursive types (e.g. a pair of records that reference each other's names) by delivering them together as one cluster, so the emitter can produce a coherent set of declarations rather than failing with an undefined-name error mid-emission.+topologicalSortTypeDefinitions :: [Packaging.TypeDefinition] -> [[Packaging.TypeDefinition]]+topologicalSortTypeDefinitions defs =++      let toPair =+              \def -> (+                Packaging.typeDefinitionName def,+                (Sets.toList (typeDependencyNames False (Core.typeSchemeBody (Packaging.typeDefinitionBody def)))))+          nameToDef = Maps.fromList (Lists.map (\d -> (Packaging.typeDefinitionName d, d)) defs)+          sorted = Sorting.topologicalSortComponents (Lists.map toPair defs)+      in (Lists.map (\names -> Optionals.cat (Lists.map (\n -> Maps.lookup n nameToDef) names)) sorted)+-- | Collect all type names referenced by a type. The boolean controls whether type-scheme references (free variables in type expressions) are included alongside structural references+typeDependencyNames :: Bool -> Core.Type -> S.Set Core.Name+typeDependencyNames withSchema typ =+    Logic.ifElse withSchema (Sets.union (Variables.freeVariablesInType typ) (typeNamesInType typ)) (Variables.freeVariablesInType typ)+-- | Collect every type name that appears anywhere inside a type expression+typeNamesInType :: Ord t0 => (Core.Type -> S.Set t0)+typeNamesInType typ0 =++      let addNames = \names -> \typ -> names+      in (Rewriting.foldOverType Coders.TraversalOrderPre addNames Sets.empty typ0)
+ src/main/haskell/Hydra/Differentiation.hs view
@@ -0,0 +1,434 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source-to-source automatic differentiation for Float64 terms.++module Hydra.Differentiation where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Equality as Equality+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Differentiate a binary primitive application given both arguments and their derivatives+differentiateBinary :: Core.Name -> Core.Term -> Core.Term -> Core.Term -> Core.Term -> Core.Term+differentiateBinary bfname a b da db =+    Logic.ifElse (Logic.or (Equality.equal bfname (Core.Name "hydra.lib.math.add")) (Equality.equal bfname (Core.Name "hydra.lib.math.addFloat64"))) (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.addFloat64")),+        Core.applicationArgument = da})),+      Core.applicationArgument = db})) (Logic.ifElse (Logic.or (Equality.equal bfname (Core.Name "hydra.lib.math.sub")) (Equality.equal bfname (Core.Name "hydra.lib.math.subFloat64"))) (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+        Core.applicationArgument = da})),+      Core.applicationArgument = db})) (Logic.ifElse (Logic.or (Equality.equal bfname (Core.Name "hydra.lib.math.mul")) (Equality.equal bfname (Core.Name "hydra.lib.math.mulFloat64"))) (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.addFloat64")),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+            Core.applicationArgument = a})),+          Core.applicationArgument = db}))})),+      Core.applicationArgument = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+          Core.applicationArgument = b})),+        Core.applicationArgument = da}))})) (Logic.ifElse (Equality.equal bfname (Core.Name "hydra.lib.math.pow")) (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+            Core.applicationArgument = a})),+          Core.applicationArgument = b}))})),+      Core.applicationArgument = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.addFloat64")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+              Core.applicationArgument = db})),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.log")),+              Core.applicationArgument = a}))}))})),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                Core.applicationArgument = b})),+              Core.applicationArgument = da}))})),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+              Core.applicationArgument = a})),+            Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))}))})) (Logic.ifElse (Equality.equal bfname (Core.Name "hydra.lib.math.atan2")) (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                Core.applicationArgument = b})),+              Core.applicationArgument = da}))})),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+              Core.applicationArgument = a})),+            Core.applicationArgument = db}))}))})),+      Core.applicationArgument = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.addFloat64")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                  Core.applicationArgument = a})),+                Core.applicationArgument = a}))})),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                Core.applicationArgument = b})),+              Core.applicationArgument = b}))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))})) (Logic.ifElse (Equality.equal bfname (Core.Name "hydra.lib.math.logBase")) (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.log")),+                  Core.applicationArgument = a}))})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                  Core.applicationArgument = db})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+                    Core.applicationArgument = b})),+                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))}))})),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.log")),+                Core.applicationArgument = b}))})),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                Core.applicationArgument = da})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+                  Core.applicationArgument = a})),+                Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))}))}))})),+      Core.applicationArgument = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.log")),+                Core.applicationArgument = a}))})),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.log")),+              Core.applicationArgument = a}))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))})) (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))))))))+-- | Differentiate a function term (Float64 -> Float64) with respect to its parameter+differentiateFunction :: Core.Term -> Core.Term+differentiateFunction term =+    case term of+      Core.TermAnnotated v0 -> differentiateFunction (Core.annotatedTermBody v0)+      Core.TermLambda v0 ->+        let paramName = Core.lambdaParameter v0+            body = Core.lambdaBody v0+        in (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = paramName,+          Core.lambdaDomain = (Core.lambdaDomain v0),+          Core.lambdaBody = (differentiateTerm paramName body)}))+      _ -> term+-- | Differentiate a term with respect to a named variable+differentiateTerm :: Core.Name -> Core.Term -> Core.Term+differentiateTerm dx term =+    case term of+      Core.TermVariable v0 -> Logic.ifElse (Equality.equal v0 dx) (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0))) (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0)))+      Core.TermLiteral _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermApplication v0 ->+        let func = Core.applicationFunction v0+            arg = Core.applicationArgument v0+        in case func of+          Core.TermVariable v1 -> Optionals.cases (primitiveDerivative v1) (differentiateTerm dx (Core.TermApplication (Core.Application {+            Core.applicationFunction = func,+            Core.applicationArgument = arg}))) (\derivTerm -> Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = derivTerm,+                Core.applicationArgument = arg}))})),+            Core.applicationArgument = (differentiateTerm dx arg)}))+          Core.TermApplication v1 ->+            let innerFunc = Core.applicationFunction v1+                innerArg = Core.applicationArgument v1+            in case innerFunc of+              Core.TermVariable v2 -> differentiateBinary v2 innerArg arg (differentiateTerm dx innerArg) (differentiateTerm dx arg)+              _ -> Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                  Core.applicationArgument = (differentiateTerm dx (Core.TermApplication (Core.Application {+                    Core.applicationFunction = func,+                    Core.applicationArgument = arg})))})),+                Core.applicationArgument = (differentiateTerm dx arg)})+          _ -> Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+              Core.applicationArgument = (differentiateTerm dx (Core.TermApplication (Core.Application {+                Core.applicationFunction = func,+                Core.applicationArgument = arg})))})),+            Core.applicationArgument = (differentiateTerm dx arg)})+      Core.TermLambda v0 -> Logic.ifElse (Equality.equal (Core.lambdaParameter v0) dx) (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.lambdaParameter v0),+        Core.lambdaDomain = (Core.lambdaDomain v0),+        Core.lambdaBody = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0)))})) (Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.lambdaParameter v0),+        Core.lambdaDomain = (Core.lambdaDomain v0),+        Core.lambdaBody = (differentiateTerm dx (Core.lambdaBody v0))}))+      Core.TermCases _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermProject _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermUnwrap _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermLet v0 -> Core.TermLet (Core.Let {+        Core.letBindings = (Lists.map (\b -> Core.Binding {+          Core.bindingName = (Core.bindingName b),+          Core.bindingTerm = (differentiateTerm dx (Core.bindingTerm b)),+          Core.bindingTypeScheme = Nothing}) (Core.letBindings v0)),+        Core.letBody = (differentiateTerm dx (Core.letBody v0))})+      Core.TermAnnotated v0 -> differentiateTerm dx (Core.annotatedTermBody v0)+      Core.TermList v0 -> Core.TermList (Lists.map (differentiateTerm dx) v0)+      Core.TermPair v0 -> Core.TermPair (differentiateTerm dx (Pairs.first v0), (differentiateTerm dx (Pairs.second v0)))+      Core.TermRecord v0 -> Core.TermRecord (Core.Record {+        Core.recordTypeName = (Core.recordTypeName v0),+        Core.recordFields = (Lists.map (\fld -> Core.Field {+          Core.fieldName = (Core.fieldName fld),+          Core.fieldTerm = (differentiateTerm dx (Core.fieldTerm fld))}) (Core.recordFields v0))})+      Core.TermTypeApplication v0 -> differentiateTerm dx (Core.typeApplicationTermBody v0)+      Core.TermTypeLambda v0 -> differentiateTerm dx (Core.typeLambdaBody v0)+      Core.TermUnit -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermSet _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermMap _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermEither _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermOptional _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermInject _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+      Core.TermWrap _ -> Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0))+-- | Compute the gradient of a term as a record of partial derivatives+gradient :: Core.Name -> [Core.Name] -> Core.Term -> Core.Term+gradient typeName vars term =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = typeName,+      Core.recordFields = (Lists.map (\v -> Core.Field {+        Core.fieldName = v,+        Core.fieldTerm = (differentiateTerm v term)}) vars)})+-- | Look up the derivative of a unary Float64 primitive+primitiveDerivative :: Core.Name -> Maybe Core.Term+primitiveDerivative name =+    Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.sin")) (Just (Core.TermVariable (Core.Name "hydra.lib.math.cos"))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.cos")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.negateFloat64")),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.sin")),+          Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.tan")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.cos")),+            Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-2.0))))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.exp")) (Just (Core.TermVariable (Core.Name "hydra.lib.math.exp"))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.log")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.sqrt")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+          Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.5)))})),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.sqrt")),+              Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))})),+          Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.asin")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.sqrt")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+                Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0)))})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))}))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.acos")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.negateFloat64")),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.sqrt")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0)))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))}))}))})),+          Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.atan")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.addFloat64")),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0)))})),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.sinh")) (Just (Core.TermVariable (Core.Name "hydra.lib.math.cosh"))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.cosh")) (Just (Core.TermVariable (Core.Name "hydra.lib.math.sinh"))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.tanh")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+          Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0)))})),+        Core.applicationArgument = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.tanh")),+              Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))})),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.tanh")),+            Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))}))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.asinh")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.sqrt")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.addFloat64")),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))})),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0)))}))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.acosh")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.sqrt")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))})),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0)))}))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.atanh")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.pow")),+          Core.applicationArgument = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.subFloat64")),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 1.0)))})),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.mulFloat64")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "_x"))}))}))})),+        Core.applicationArgument = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.negate")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (-1.0))))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.abs")) (Just (Core.TermVariable (Core.Name "hydra.lib.math.signum"))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.ceiling")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0)))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.floor")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0)))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.round")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0)))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.truncate")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0)))}))) (Logic.ifElse (Equality.equal name (Core.Name "hydra.lib.math.signum")) (Just (Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "_x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 0.0)))}))) Nothing)))))))))))))))))))))
+ src/main/haskell/Hydra/Dsl/Ast.hs view
@@ -0,0 +1,896 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.ast++module Hydra.Dsl.Ast where+import qualified Hydra.Ast as Ast+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL injection for the both variant of hydra.ast.Associativity+associativityBoth :: Typed.TypedTerm Ast.Associativity+associativityBoth =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "both"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the left variant of hydra.ast.Associativity+associativityLeft :: Typed.TypedTerm Ast.Associativity+associativityLeft =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "left"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the none variant of hydra.ast.Associativity+associativityNone :: Typed.TypedTerm Ast.Associativity+associativityNone =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "none"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the right variant of hydra.ast.Associativity+associativityRight :: Typed.TypedTerm Ast.Associativity+associativityRight =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "right"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for hydra.ast.BlockStyle+blockStyle :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm Ast.BlockStyle+blockStyle indent newlineBeforeContent newlineAfterContent =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "indent"),+          Core.fieldTerm = (Typed.unTypedTerm indent)},+        Core.Field {+          Core.fieldName = (Core.Name "newlineBeforeContent"),+          Core.fieldTerm = (Typed.unTypedTerm newlineBeforeContent)},+        Core.Field {+          Core.fieldName = (Core.Name "newlineAfterContent"),+          Core.fieldTerm = (Typed.unTypedTerm newlineAfterContent)}]}))+-- | DSL accessor for the indent field of hydra.ast.BlockStyle+blockStyleIndent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm (Maybe String)+blockStyleIndent x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+        Core.projectionFieldName = (Core.Name "indent")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the newlineAfterContent field of hydra.ast.BlockStyle+blockStyleNewlineAfterContent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Bool+blockStyleNewlineAfterContent x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+        Core.projectionFieldName = (Core.Name "newlineAfterContent")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the newlineBeforeContent field of hydra.ast.BlockStyle+blockStyleNewlineBeforeContent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Bool+blockStyleNewlineBeforeContent x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+        Core.projectionFieldName = (Core.Name "newlineBeforeContent")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the indent field of hydra.ast.BlockStyle+blockStyleWithIndent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Ast.BlockStyle+blockStyleWithIndent original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "indent"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "newlineBeforeContent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+              Core.projectionFieldName = (Core.Name "newlineBeforeContent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "newlineAfterContent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+              Core.projectionFieldName = (Core.Name "newlineAfterContent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the newlineAfterContent field of hydra.ast.BlockStyle+blockStyleWithNewlineAfterContent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Bool -> Typed.TypedTerm Ast.BlockStyle+blockStyleWithNewlineAfterContent original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "indent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+              Core.projectionFieldName = (Core.Name "indent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "newlineBeforeContent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+              Core.projectionFieldName = (Core.Name "newlineBeforeContent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "newlineAfterContent"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the newlineBeforeContent field of hydra.ast.BlockStyle+blockStyleWithNewlineBeforeContent :: Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Bool -> Typed.TypedTerm Ast.BlockStyle+blockStyleWithNewlineBeforeContent original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "indent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+              Core.projectionFieldName = (Core.Name "indent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "newlineBeforeContent"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "newlineAfterContent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+              Core.projectionFieldName = (Core.Name "newlineAfterContent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.ast.BracketExpr+bracketExpr :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Ast.BracketExpr+bracketExpr brackets enclosed style =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "brackets"),+          Core.fieldTerm = (Typed.unTypedTerm brackets)},+        Core.Field {+          Core.fieldName = (Core.Name "enclosed"),+          Core.fieldTerm = (Typed.unTypedTerm enclosed)},+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (Typed.unTypedTerm style)}]}))+-- | DSL accessor for the brackets field of hydra.ast.BracketExpr+bracketExprBrackets :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.Brackets+bracketExprBrackets x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+        Core.projectionFieldName = (Core.Name "brackets")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the enclosed field of hydra.ast.BracketExpr+bracketExprEnclosed :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.Expr+bracketExprEnclosed x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+        Core.projectionFieldName = (Core.Name "enclosed")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the style field of hydra.ast.BracketExpr+bracketExprStyle :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.BlockStyle+bracketExprStyle x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+        Core.projectionFieldName = (Core.Name "style")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the brackets field of hydra.ast.BracketExpr+bracketExprWithBrackets :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.BracketExpr+bracketExprWithBrackets original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "brackets"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "enclosed"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+              Core.projectionFieldName = (Core.Name "enclosed")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+              Core.projectionFieldName = (Core.Name "style")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the enclosed field of hydra.ast.BracketExpr+bracketExprWithEnclosed :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.BracketExpr+bracketExprWithEnclosed original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "brackets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+              Core.projectionFieldName = (Core.Name "brackets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enclosed"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+              Core.projectionFieldName = (Core.Name "style")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the style field of hydra.ast.BracketExpr+bracketExprWithStyle :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.BlockStyle -> Typed.TypedTerm Ast.BracketExpr+bracketExprWithStyle original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "brackets"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+              Core.projectionFieldName = (Core.Name "brackets")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enclosed"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+              Core.projectionFieldName = (Core.Name "enclosed")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.ast.Brackets+brackets :: Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm Ast.Brackets+brackets open close =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Brackets"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "open"),+          Core.fieldTerm = (Typed.unTypedTerm open)},+        Core.Field {+          Core.fieldName = (Core.Name "close"),+          Core.fieldTerm = (Typed.unTypedTerm close)}]}))+-- | DSL accessor for the close field of hydra.ast.Brackets+bracketsClose :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.Symbol+bracketsClose x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"),+        Core.projectionFieldName = (Core.Name "close")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the open field of hydra.ast.Brackets+bracketsOpen :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.Symbol+bracketsOpen x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"),+        Core.projectionFieldName = (Core.Name "open")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the close field of hydra.ast.Brackets+bracketsWithClose :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm Ast.Brackets+bracketsWithClose original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Brackets"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "open"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"),+              Core.projectionFieldName = (Core.Name "open")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "close"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the open field of hydra.ast.Brackets+bracketsWithOpen :: Typed.TypedTerm Ast.Brackets -> Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm Ast.Brackets+bracketsWithOpen original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Brackets"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "open"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "close"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"),+              Core.projectionFieldName = (Core.Name "close")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the brackets variant of hydra.ast.Expr+exprBrackets :: Typed.TypedTerm Ast.BracketExpr -> Typed.TypedTerm Ast.Expr+exprBrackets x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "brackets"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the const variant of hydra.ast.Expr+exprConst :: Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm Ast.Expr+exprConst x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "const"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the indent variant of hydra.ast.Expr+exprIndent :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.Expr+exprIndent x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "indent"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the op variant of hydra.ast.Expr+exprOp :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Expr+exprOp x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "op"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the seq variant of hydra.ast.Expr+exprSeq :: Typed.TypedTerm Ast.SeqExpr -> Typed.TypedTerm Ast.Expr+exprSeq x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "seq"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the allLines variant of hydra.ast.IndentStyle+indentStyleAllLines :: Typed.TypedTerm String -> Typed.TypedTerm Ast.IndentStyle+indentStyleAllLines x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "allLines"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the subsequentLines variant of hydra.ast.IndentStyle+indentStyleSubsequentLines :: Typed.TypedTerm String -> Typed.TypedTerm Ast.IndentStyle+indentStyleSubsequentLines x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "subsequentLines"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.ast.IndentedExpression+indentedExpression :: Typed.TypedTerm Ast.IndentStyle -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.IndentedExpression+indentedExpression style expr =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (Typed.unTypedTerm style)},+        Core.Field {+          Core.fieldName = (Core.Name "expr"),+          Core.fieldTerm = (Typed.unTypedTerm expr)}]}))+-- | DSL accessor for the expr field of hydra.ast.IndentedExpression+indentedExpressionExpr :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.Expr+indentedExpressionExpr x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"),+        Core.projectionFieldName = (Core.Name "expr")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the style field of hydra.ast.IndentedExpression+indentedExpressionStyle :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.IndentStyle+indentedExpressionStyle x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"),+        Core.projectionFieldName = (Core.Name "style")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the expr field of hydra.ast.IndentedExpression+indentedExpressionWithExpr :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.IndentedExpression+indentedExpressionWithExpr original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"),+              Core.projectionFieldName = (Core.Name "style")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expr"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the style field of hydra.ast.IndentedExpression+indentedExpressionWithStyle :: Typed.TypedTerm Ast.IndentedExpression -> Typed.TypedTerm Ast.IndentStyle -> Typed.TypedTerm Ast.IndentedExpression+indentedExpressionWithStyle original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expr"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"),+              Core.projectionFieldName = (Core.Name "expr")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.ast.Op+op :: Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Precedence -> Typed.TypedTerm Ast.Associativity -> Typed.TypedTerm Ast.Op+op symbol padding precedence associativity =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Op"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "symbol"),+          Core.fieldTerm = (Typed.unTypedTerm symbol)},+        Core.Field {+          Core.fieldName = (Core.Name "padding"),+          Core.fieldTerm = (Typed.unTypedTerm padding)},+        Core.Field {+          Core.fieldName = (Core.Name "precedence"),+          Core.fieldTerm = (Typed.unTypedTerm precedence)},+        Core.Field {+          Core.fieldName = (Core.Name "associativity"),+          Core.fieldTerm = (Typed.unTypedTerm associativity)}]}))+-- | DSL accessor for the associativity field of hydra.ast.Op+opAssociativity :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Associativity+opAssociativity x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+        Core.projectionFieldName = (Core.Name "associativity")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.ast.OpExpr+opExpr :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.OpExpr+opExpr op lhs rhs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (Typed.unTypedTerm op)},+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Typed.unTypedTerm lhs)},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))+-- | DSL accessor for the lhs field of hydra.ast.OpExpr+opExprLhs :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Expr+opExprLhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+        Core.projectionFieldName = (Core.Name "lhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the op field of hydra.ast.OpExpr+opExprOp :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Op+opExprOp x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+        Core.projectionFieldName = (Core.Name "op")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the rhs field of hydra.ast.OpExpr+opExprRhs :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Expr+opExprRhs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+        Core.projectionFieldName = (Core.Name "rhs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the lhs field of hydra.ast.OpExpr+opExprWithLhs :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.OpExpr+opExprWithLhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+              Core.projectionFieldName = (Core.Name "op")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the op field of hydra.ast.OpExpr+opExprWithOp :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.OpExpr+opExprWithOp original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+              Core.projectionFieldName = (Core.Name "rhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the rhs field of hydra.ast.OpExpr+opExprWithRhs :: Typed.TypedTerm Ast.OpExpr -> Typed.TypedTerm Ast.Expr -> Typed.TypedTerm Ast.OpExpr+opExprWithRhs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+              Core.projectionFieldName = (Core.Name "op")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+              Core.projectionFieldName = (Core.Name "lhs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL accessor for the padding field of hydra.ast.Op+opPadding :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Padding+opPadding x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+        Core.projectionFieldName = (Core.Name "padding")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the precedence field of hydra.ast.Op+opPrecedence :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Precedence+opPrecedence x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+        Core.projectionFieldName = (Core.Name "precedence")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the symbol field of hydra.ast.Op+opSymbol :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Symbol+opSymbol x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+        Core.projectionFieldName = (Core.Name "symbol")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the associativity field of hydra.ast.Op+opWithAssociativity :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Associativity -> Typed.TypedTerm Ast.Op+opWithAssociativity original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Op"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "symbol"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "symbol")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "padding"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "padding")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "precedence"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "precedence")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "associativity"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the padding field of hydra.ast.Op+opWithPadding :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Op+opWithPadding original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Op"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "symbol"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "symbol")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "padding"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "precedence"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "precedence")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "associativity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "associativity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the precedence field of hydra.ast.Op+opWithPrecedence :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Precedence -> Typed.TypedTerm Ast.Op+opWithPrecedence original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Op"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "symbol"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "symbol")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "padding"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "padding")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "precedence"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "associativity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "associativity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the symbol field of hydra.ast.Op+opWithSymbol :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm Ast.Op+opWithSymbol original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Op"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "symbol"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "padding"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "padding")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "precedence"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "precedence")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "associativity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+              Core.projectionFieldName = (Core.Name "associativity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.ast.Padding+padding :: Typed.TypedTerm Ast.Ws -> Typed.TypedTerm Ast.Ws -> Typed.TypedTerm Ast.Padding+padding left right =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Padding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm left)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm right)}]}))+-- | DSL accessor for the left field of hydra.ast.Padding+paddingLeft :: Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Ws+paddingLeft x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Padding"),+        Core.projectionFieldName = (Core.Name "left")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the right field of hydra.ast.Padding+paddingRight :: Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Ws+paddingRight x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.Padding"),+        Core.projectionFieldName = (Core.Name "right")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the left field of hydra.ast.Padding+paddingWithLeft :: Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Ws -> Typed.TypedTerm Ast.Padding+paddingWithLeft original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Padding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Padding"),+              Core.projectionFieldName = (Core.Name "right")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the right field of hydra.ast.Padding+paddingWithRight :: Typed.TypedTerm Ast.Padding -> Typed.TypedTerm Ast.Ws -> Typed.TypedTerm Ast.Padding+paddingWithRight original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Padding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.Padding"),+              Core.projectionFieldName = (Core.Name "left")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for the hydra.ast.Precedence wrapper+precedence :: Typed.TypedTerm Int -> Typed.TypedTerm Ast.Precedence+precedence x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.ast.SeqExpr+seqExpr :: Typed.TypedTerm Ast.Op -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.SeqExpr+seqExpr op elements =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (Typed.unTypedTerm op)},+        Core.Field {+          Core.fieldName = (Core.Name "elements"),+          Core.fieldTerm = (Typed.unTypedTerm elements)}]}))+-- | DSL accessor for the elements field of hydra.ast.SeqExpr+seqExprElements :: Typed.TypedTerm Ast.SeqExpr -> Typed.TypedTerm [Ast.Expr]+seqExprElements x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"),+        Core.projectionFieldName = (Core.Name "elements")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the op field of hydra.ast.SeqExpr+seqExprOp :: Typed.TypedTerm Ast.SeqExpr -> Typed.TypedTerm Ast.Op+seqExprOp x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"),+        Core.projectionFieldName = (Core.Name "op")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the elements field of hydra.ast.SeqExpr+seqExprWithElements :: Typed.TypedTerm Ast.SeqExpr -> Typed.TypedTerm [Ast.Expr] -> Typed.TypedTerm Ast.SeqExpr+seqExprWithElements original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"),+              Core.projectionFieldName = (Core.Name "op")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "elements"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the op field of hydra.ast.SeqExpr+seqExprWithOp :: Typed.TypedTerm Ast.SeqExpr -> Typed.TypedTerm Ast.Op -> Typed.TypedTerm Ast.SeqExpr+seqExprWithOp original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "elements"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"),+              Core.projectionFieldName = (Core.Name "elements")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.ast.Symbol wrapper+symbol :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Symbol+symbol x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.ast.Precedence+unPrecedence :: Typed.TypedTerm Ast.Precedence -> Typed.TypedTerm Int+unPrecedence x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.ast.Precedence")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.ast.Symbol+unSymbol :: Typed.TypedTerm Ast.Symbol -> Typed.TypedTerm String+unSymbol x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.ast.Symbol")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL injection for the break variant of hydra.ast.Ws+wsBreak :: Typed.TypedTerm Ast.Ws+wsBreak =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "break"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the breakAndIndent variant of hydra.ast.Ws+wsBreakAndIndent :: Typed.TypedTerm String -> Typed.TypedTerm Ast.Ws+wsBreakAndIndent x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "breakAndIndent"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the doubleBreak variant of hydra.ast.Ws+wsDoubleBreak :: Typed.TypedTerm Ast.Ws+wsDoubleBreak =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "doubleBreak"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the none variant of hydra.ast.Ws+wsNone :: Typed.TypedTerm Ast.Ws+wsNone =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "none"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the space variant of hydra.ast.Ws+wsSpace :: Typed.TypedTerm Ast.Ws+wsSpace =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "space"),+        Core.fieldTerm = Core.TermUnit}}))
+ src/main/haskell/Hydra/Dsl/Coders.hs view
@@ -0,0 +1,1906 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.coders++module Hydra.Dsl.Coders where+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Errors as DslErrors+import qualified Hydra.Dsl.Graph as DslGraph+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | DSL constructor for hydra.coders.Adapter+adapter :: Typed.TypedTerm Bool -> Typed.TypedTerm t1 -> Typed.TypedTerm t2 -> Typed.TypedTerm (Coders.Coder v1 v2) -> Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2)+adapter isLossy source target coder =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Adapter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isLossy"),+          Core.fieldTerm = (Typed.unTypedTerm isLossy)},+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Typed.unTypedTerm source)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm target)},+        Core.Field {+          Core.fieldName = (Core.Name "coder"),+          Core.fieldTerm = (Typed.unTypedTerm coder)}]}))+-- | DSL accessor for the coder field of hydra.coders.Adapter+adapterCoder :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm (Coders.Coder v1 v2)+adapterCoder x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+        Core.projectionFieldName = (Core.Name "coder")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.coders.AdapterContext+adapterContext :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Coders.Language -> Typed.TypedTerm (M.Map Core.Name (Coders.Adapter Core.Type Core.Type Core.Term Core.Term)) -> Typed.TypedTerm Coders.AdapterContext+adapterContext graph language adapters =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm graph)},+        Core.Field {+          Core.fieldName = (Core.Name "language"),+          Core.fieldTerm = (Typed.unTypedTerm language)},+        Core.Field {+          Core.fieldName = (Core.Name "adapters"),+          Core.fieldTerm = (Typed.unTypedTerm adapters)}]}))+-- | DSL accessor for the adapters field of hydra.coders.AdapterContext+adapterContextAdapters :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm (M.Map Core.Name (Coders.Adapter Core.Type Core.Type Core.Term Core.Term))+adapterContextAdapters x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+        Core.projectionFieldName = (Core.Name "adapters")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the graph field of hydra.coders.AdapterContext+adapterContextGraph :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm Graph.Graph+adapterContextGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+        Core.projectionFieldName = (Core.Name "graph")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the language field of hydra.coders.AdapterContext+adapterContextLanguage :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm Coders.Language+adapterContextLanguage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+        Core.projectionFieldName = (Core.Name "language")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the adapters field of hydra.coders.AdapterContext+adapterContextWithAdapters :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm (M.Map Core.Name (Coders.Adapter Core.Type Core.Type Core.Term Core.Term)) -> Typed.TypedTerm Coders.AdapterContext+adapterContextWithAdapters original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "language"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+              Core.projectionFieldName = (Core.Name "language")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "adapters"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the graph field of hydra.coders.AdapterContext+adapterContextWithGraph :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm Graph.Graph -> Typed.TypedTerm Coders.AdapterContext+adapterContextWithGraph original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "language"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+              Core.projectionFieldName = (Core.Name "language")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "adapters"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+              Core.projectionFieldName = (Core.Name "adapters")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the language field of hydra.coders.AdapterContext+adapterContextWithLanguage :: Typed.TypedTerm Coders.AdapterContext -> Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.AdapterContext+adapterContextWithLanguage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.AdapterContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "language"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "adapters"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.AdapterContext"),+              Core.projectionFieldName = (Core.Name "adapters")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL accessor for the isLossy field of hydra.coders.Adapter+adapterIsLossy :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm Bool+adapterIsLossy x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+        Core.projectionFieldName = (Core.Name "isLossy")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the source field of hydra.coders.Adapter+adapterSource :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm t1+adapterSource x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+        Core.projectionFieldName = (Core.Name "source")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the target field of hydra.coders.Adapter+adapterTarget :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm t2+adapterTarget x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+        Core.projectionFieldName = (Core.Name "target")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the coder field of hydra.coders.Adapter+adapterWithCoder :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm (Coders.Coder v1 v2) -> Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2)+adapterWithCoder original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Adapter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isLossy"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "isLossy")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "source")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "coder"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the isLossy field of hydra.coders.Adapter+adapterWithIsLossy :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm Bool -> Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2)+adapterWithIsLossy original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Adapter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isLossy"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "source")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "coder"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "coder")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the source field of hydra.coders.Adapter+adapterWithSource :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm t1 -> Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2)+adapterWithSource original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Adapter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isLossy"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "isLossy")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "coder"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "coder")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the target field of hydra.coders.Adapter+adapterWithTarget :: Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm t2 -> Typed.TypedTerm (Coders.Adapter t1 t2 v1 v2)+adapterWithTarget original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Adapter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "isLossy"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "isLossy")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "source")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "coder"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Adapter"),+              Core.projectionFieldName = (Core.Name "coder")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.coders.Bicoder+bicoder :: Typed.TypedTerm (t1 -> Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm (t2 -> Coders.Adapter t2 t1 v2 v1) -> Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2)+bicoder encode decode =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Bicoder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm encode)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm decode)}]}))+-- | DSL accessor for the decode field of hydra.coders.Bicoder+bicoderDecode :: Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2) -> Typed.TypedTerm (t2 -> Coders.Adapter t2 t1 v2 v1)+bicoderDecode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Bicoder"),+        Core.projectionFieldName = (Core.Name "decode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the encode field of hydra.coders.Bicoder+bicoderEncode :: Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2) -> Typed.TypedTerm (t1 -> Coders.Adapter t1 t2 v1 v2)+bicoderEncode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Bicoder"),+        Core.projectionFieldName = (Core.Name "encode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the decode field of hydra.coders.Bicoder+bicoderWithDecode :: Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2) -> Typed.TypedTerm (t2 -> Coders.Adapter t2 t1 v2 v1) -> Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2)+bicoderWithDecode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Bicoder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Bicoder"),+              Core.projectionFieldName = (Core.Name "encode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the encode field of hydra.coders.Bicoder+bicoderWithEncode :: Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2) -> Typed.TypedTerm (t1 -> Coders.Adapter t1 t2 v1 v2) -> Typed.TypedTerm (Coders.Bicoder t1 t2 v1 v2)+bicoderWithEncode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Bicoder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Bicoder"),+              Core.projectionFieldName = (Core.Name "decode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.coders.CaseConventions+caseConventions :: Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventions constant directory enumValue field file module_ term termVariable type_ typeVariable =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Typed.unTypedTerm constant)},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Typed.unTypedTerm directory)},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Typed.unTypedTerm enumValue)},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Typed.unTypedTerm field)},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Typed.unTypedTerm file)},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Typed.unTypedTerm module_)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm term)},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Typed.unTypedTerm termVariable)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Typed.unTypedTerm typeVariable)}]}))+-- | DSL accessor for the constant field of hydra.coders.CaseConventions+caseConventionsConstant :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsConstant x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "constant")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the directory field of hydra.coders.CaseConventions+caseConventionsDirectory :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsDirectory x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "directory")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the enumValue field of hydra.coders.CaseConventions+caseConventionsEnumValue :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsEnumValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "enumValue")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the field field of hydra.coders.CaseConventions+caseConventionsField :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsField x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "field")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the file field of hydra.coders.CaseConventions+caseConventionsFile :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsFile x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "file")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the module field of hydra.coders.CaseConventions+caseConventionsModule :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsModule x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "module")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the term field of hydra.coders.CaseConventions+caseConventionsTerm :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsTerm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "term")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the termVariable field of hydra.coders.CaseConventions+caseConventionsTermVariable :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsTermVariable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "termVariable")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.coders.CaseConventions+caseConventionsType :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeVariable field of hydra.coders.CaseConventions+caseConventionsTypeVariable :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention+caseConventionsTypeVariable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+        Core.projectionFieldName = (Core.Name "typeVariable")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the constant field of hydra.coders.CaseConventions+caseConventionsWithConstant :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithConstant original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the directory field of hydra.coders.CaseConventions+caseConventionsWithDirectory :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithDirectory original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the enumValue field of hydra.coders.CaseConventions+caseConventionsWithEnumValue :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithEnumValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the field field of hydra.coders.CaseConventions+caseConventionsWithField :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithField original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the file field of hydra.coders.CaseConventions+caseConventionsWithFile :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithFile original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the module field of hydra.coders.CaseConventions+caseConventionsWithModule :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithModule original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the term field of hydra.coders.CaseConventions+caseConventionsWithTerm :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithTerm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the termVariable field of hydra.coders.CaseConventions+caseConventionsWithTermVariable :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithTermVariable original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.coders.CaseConventions+caseConventionsWithType :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "typeVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeVariable field of hydra.coders.CaseConventions+caseConventionsWithTypeVariable :: Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm Coders.CaseConventions+caseConventionsWithTypeVariable original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "constant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "directory")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "enumValue")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "file")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "termVariable")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.coders.Coder+coder :: Typed.TypedTerm (Typing.InferenceContext -> v1 -> Either Errors.Error v2) -> Typed.TypedTerm (Typing.InferenceContext -> v2 -> Either Errors.Error v1) -> Typed.TypedTerm (Coders.Coder v1 v2)+coder encode decode =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Coder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm encode)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm decode)}]}))+-- | DSL accessor for the decode field of hydra.coders.Coder+coderDecode :: Typed.TypedTerm (Coders.Coder v1 v2) -> Typed.TypedTerm (Typing.InferenceContext -> v2 -> Either Errors.Error v1)+coderDecode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Coder"),+        Core.projectionFieldName = (Core.Name "decode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL injection for the decode variant of hydra.coders.CoderDirection+coderDirectionDecode :: Typed.TypedTerm Coders.CoderDirection+coderDirectionDecode =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "decode"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the encode variant of hydra.coders.CoderDirection+coderDirectionEncode :: Typed.TypedTerm Coders.CoderDirection+coderDirectionEncode =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "encode"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL accessor for the encode field of hydra.coders.Coder+coderEncode :: Typed.TypedTerm (Coders.Coder v1 v2) -> Typed.TypedTerm (Typing.InferenceContext -> v1 -> Either Errors.Error v2)+coderEncode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Coder"),+        Core.projectionFieldName = (Core.Name "encode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the decode field of hydra.coders.Coder+coderWithDecode :: Typed.TypedTerm (Coders.Coder v1 v2) -> Typed.TypedTerm (Typing.InferenceContext -> v2 -> Either Errors.Error v1) -> Typed.TypedTerm (Coders.Coder v1 v2)+coderWithDecode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Coder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Coder"),+              Core.projectionFieldName = (Core.Name "encode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the encode field of hydra.coders.Coder+coderWithEncode :: Typed.TypedTerm (Coders.Coder v1 v2) -> Typed.TypedTerm (Typing.InferenceContext -> v1 -> Either Errors.Error v2) -> Typed.TypedTerm (Coders.Coder v1 v2)+coderWithEncode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Coder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Coder"),+              Core.projectionFieldName = (Core.Name "decode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.coders.Language+language :: Typed.TypedTerm Coders.LanguageName -> Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Coders.LanguageFeature) -> Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Util.FileExtension -> Typed.TypedTerm Coders.Language+language name constraints supportedFeatures caseConventions defaultFileExtension =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Language"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm constraints)},+        Core.Field {+          Core.fieldName = (Core.Name "supportedFeatures"),+          Core.fieldTerm = (Typed.unTypedTerm supportedFeatures)},+        Core.Field {+          Core.fieldName = (Core.Name "caseConventions"),+          Core.fieldTerm = (Typed.unTypedTerm caseConventions)},+        Core.Field {+          Core.fieldName = (Core.Name "defaultFileExtension"),+          Core.fieldTerm = (Typed.unTypedTerm defaultFileExtension)}]}))+-- | DSL accessor for the caseConventions field of hydra.coders.Language+languageCaseConventions :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.CaseConventions+languageCaseConventions x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+        Core.projectionFieldName = (Core.Name "caseConventions")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the constraints field of hydra.coders.Language+languageConstraints :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraints x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+        Core.projectionFieldName = (Core.Name "constraints")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.coders.LanguageConstraints+languageConstraints2 :: Typed.TypedTerm (S.Set Variants.LiteralVariant) -> Typed.TypedTerm (S.Set Core.FloatType) -> Typed.TypedTerm (S.Set Core.IntegerType) -> Typed.TypedTerm (S.Set Variants.TermVariant) -> Typed.TypedTerm (S.Set Variants.TypeVariant) -> Typed.TypedTerm (Core.Type -> Bool) -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraints2 literalVariants floatTypes integerTypes termVariants typeVariants types =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "literalVariants"),+          Core.fieldTerm = (Typed.unTypedTerm literalVariants)},+        Core.Field {+          Core.fieldName = (Core.Name "floatTypes"),+          Core.fieldTerm = (Typed.unTypedTerm floatTypes)},+        Core.Field {+          Core.fieldName = (Core.Name "integerTypes"),+          Core.fieldTerm = (Typed.unTypedTerm integerTypes)},+        Core.Field {+          Core.fieldName = (Core.Name "termVariants"),+          Core.fieldTerm = (Typed.unTypedTerm termVariants)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariants"),+          Core.fieldTerm = (Typed.unTypedTerm typeVariants)},+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Typed.unTypedTerm types)}]}))+-- | DSL accessor for the floatTypes field of hydra.coders.LanguageConstraints+languageConstraintsFloatTypes :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Core.FloatType)+languageConstraintsFloatTypes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+        Core.projectionFieldName = (Core.Name "floatTypes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the integerTypes field of hydra.coders.LanguageConstraints+languageConstraintsIntegerTypes :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Core.IntegerType)+languageConstraintsIntegerTypes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+        Core.projectionFieldName = (Core.Name "integerTypes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the literalVariants field of hydra.coders.LanguageConstraints+languageConstraintsLiteralVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.LiteralVariant)+languageConstraintsLiteralVariants x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+        Core.projectionFieldName = (Core.Name "literalVariants")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the termVariants field of hydra.coders.LanguageConstraints+languageConstraintsTermVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.TermVariant)+languageConstraintsTermVariants x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+        Core.projectionFieldName = (Core.Name "termVariants")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeVariants field of hydra.coders.LanguageConstraints+languageConstraintsTypeVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.TypeVariant)+languageConstraintsTypeVariants x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+        Core.projectionFieldName = (Core.Name "typeVariants")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the types field of hydra.coders.LanguageConstraints+languageConstraintsTypes :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (Core.Type -> Bool)+languageConstraintsTypes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+        Core.projectionFieldName = (Core.Name "types")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the floatTypes field of hydra.coders.LanguageConstraints+languageConstraintsWithFloatTypes :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Core.FloatType) -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraintsWithFloatTypes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "literalVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "literalVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "floatTypes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "integerTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "integerTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "termVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "typeVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "types")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the integerTypes field of hydra.coders.LanguageConstraints+languageConstraintsWithIntegerTypes :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Core.IntegerType) -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraintsWithIntegerTypes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "literalVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "literalVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "floatTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "floatTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "integerTypes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "termVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "termVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "typeVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "types")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the literalVariants field of hydra.coders.LanguageConstraints+languageConstraintsWithLiteralVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.LiteralVariant) -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraintsWithLiteralVariants original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "literalVariants"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "floatTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "floatTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "integerTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "integerTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "termVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "typeVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "types")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the termVariants field of hydra.coders.LanguageConstraints+languageConstraintsWithTermVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.TermVariant) -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraintsWithTermVariants original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "literalVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "literalVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "floatTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "floatTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "integerTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "integerTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariants"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "typeVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "types")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeVariants field of hydra.coders.LanguageConstraints+languageConstraintsWithTypeVariants :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (S.Set Variants.TypeVariant) -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraintsWithTypeVariants original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "literalVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "literalVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "floatTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "floatTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "integerTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "integerTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "termVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariants"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "types")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the types field of hydra.coders.LanguageConstraints+languageConstraintsWithTypes :: Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm (Core.Type -> Bool) -> Typed.TypedTerm Coders.LanguageConstraints+languageConstraintsWithTypes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "literalVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "literalVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "floatTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "floatTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "integerTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "integerTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "termVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariants"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.LanguageConstraints"),+              Core.projectionFieldName = (Core.Name "typeVariants")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL accessor for the defaultFileExtension field of hydra.coders.Language+languageDefaultFileExtension :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Util.FileExtension+languageDefaultFileExtension x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+        Core.projectionFieldName = (Core.Name "defaultFileExtension")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL injection for the nestedCaseStatements variant of hydra.coders.LanguageFeature+languageFeatureNestedCaseStatements :: Typed.TypedTerm Coders.LanguageFeature+languageFeatureNestedCaseStatements =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nestedCaseStatements"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the nestedPolymorphicLetBindings variant of hydra.coders.LanguageFeature+languageFeatureNestedPolymorphicLetBindings :: Typed.TypedTerm Coders.LanguageFeature+languageFeatureNestedPolymorphicLetBindings =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nestedPolymorphicLetBindings"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the partialApplication variant of hydra.coders.LanguageFeature+languageFeaturePartialApplication :: Typed.TypedTerm Coders.LanguageFeature+languageFeaturePartialApplication =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "partialApplication"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL accessor for the name field of hydra.coders.Language+languageName :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.LanguageName+languageName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.coders.LanguageName wrapper+languageName2 :: Typed.TypedTerm String -> Typed.TypedTerm Coders.LanguageName+languageName2 x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL accessor for the supportedFeatures field of hydra.coders.Language+languageSupportedFeatures :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm (S.Set Coders.LanguageFeature)+languageSupportedFeatures x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+        Core.projectionFieldName = (Core.Name "supportedFeatures")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the caseConventions field of hydra.coders.Language+languageWithCaseConventions :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.CaseConventions -> Typed.TypedTerm Coders.Language+languageWithCaseConventions original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Language"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "supportedFeatures"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "supportedFeatures")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "caseConventions"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "defaultFileExtension"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "defaultFileExtension")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the constraints field of hydra.coders.Language+languageWithConstraints :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.LanguageConstraints -> Typed.TypedTerm Coders.Language+languageWithConstraints original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Language"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "supportedFeatures"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "supportedFeatures")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "caseConventions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "caseConventions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultFileExtension"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "defaultFileExtension")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the defaultFileExtension field of hydra.coders.Language+languageWithDefaultFileExtension :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Util.FileExtension -> Typed.TypedTerm Coders.Language+languageWithDefaultFileExtension original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Language"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "supportedFeatures"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "supportedFeatures")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "caseConventions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "caseConventions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultFileExtension"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.coders.Language+languageWithName :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm Coders.LanguageName -> Typed.TypedTerm Coders.Language+languageWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Language"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "supportedFeatures"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "supportedFeatures")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "caseConventions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "caseConventions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultFileExtension"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "defaultFileExtension")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the supportedFeatures field of hydra.coders.Language+languageWithSupportedFeatures :: Typed.TypedTerm Coders.Language -> Typed.TypedTerm (S.Set Coders.LanguageFeature) -> Typed.TypedTerm Coders.Language+languageWithSupportedFeatures original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.Language"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "supportedFeatures"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "caseConventions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "caseConventions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultFileExtension"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.coders.Language"),+              Core.projectionFieldName = (Core.Name "defaultFileExtension")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the post variant of hydra.coders.TraversalOrder+traversalOrderPost :: Typed.TypedTerm Coders.TraversalOrder+traversalOrderPost =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "post"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the pre variant of hydra.coders.TraversalOrder+traversalOrderPre :: Typed.TypedTerm Coders.TraversalOrder+traversalOrderPre =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pre"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL accessor for the body of hydra.coders.LanguageName+unLanguageName :: Typed.TypedTerm Coders.LanguageName -> Typed.TypedTerm String+unLanguageName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.coders.LanguageName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Core.hs view
@@ -0,0 +1,2206 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.core++module Hydra.Dsl.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.ByteString as B+import qualified Data.Int as I+import qualified Data.Map as M+import qualified Data.Set as S+-- | DSL constructor for hydra.core.AnnotatedTerm+annotatedTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.AnnotatedTerm+annotatedTerm body annotation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm annotation)}]}))+-- | DSL accessor for the annotation field of hydra.core.AnnotatedTerm+annotatedTermAnnotation :: Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm Core.Term+annotatedTermAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+        Core.projectionFieldName = (Core.Name "annotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body field of hydra.core.AnnotatedTerm+annotatedTermBody :: Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm Core.Term+annotatedTermBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the annotation field of hydra.core.AnnotatedTerm+annotatedTermWithAnnotation :: Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.AnnotatedTerm+annotatedTermWithAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the body field of hydra.core.AnnotatedTerm+annotatedTermWithBody :: Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.AnnotatedTerm+annotatedTermWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+              Core.projectionFieldName = (Core.Name "annotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.AnnotatedType+annotatedType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.AnnotatedType+annotatedType body annotation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm annotation)}]}))+-- | DSL accessor for the annotation field of hydra.core.AnnotatedType+annotatedTypeAnnotation :: Typed.TypedTerm Core.AnnotatedType -> Typed.TypedTerm Core.Term+annotatedTypeAnnotation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"),+        Core.projectionFieldName = (Core.Name "annotation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body field of hydra.core.AnnotatedType+annotatedTypeBody :: Typed.TypedTerm Core.AnnotatedType -> Typed.TypedTerm Core.Type+annotatedTypeBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the annotation field of hydra.core.AnnotatedType+annotatedTypeWithAnnotation :: Typed.TypedTerm Core.AnnotatedType -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.AnnotatedType+annotatedTypeWithAnnotation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the body field of hydra.core.AnnotatedType+annotatedTypeWithBody :: Typed.TypedTerm Core.AnnotatedType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.AnnotatedType+annotatedTypeWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"),+              Core.projectionFieldName = (Core.Name "annotation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.Application+application :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Application+application function argument =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Application"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (Typed.unTypedTerm function)},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (Typed.unTypedTerm argument)}]}))+-- | DSL accessor for the argument field of hydra.core.Application+applicationArgument :: Typed.TypedTerm Core.Application -> Typed.TypedTerm Core.Term+applicationArgument x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Application"),+        Core.projectionFieldName = (Core.Name "argument")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the function field of hydra.core.Application+applicationFunction :: Typed.TypedTerm Core.Application -> Typed.TypedTerm Core.Term+applicationFunction x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Application"),+        Core.projectionFieldName = (Core.Name "function")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.core.ApplicationType+applicationType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.ApplicationType+applicationType function argument =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (Typed.unTypedTerm function)},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (Typed.unTypedTerm argument)}]}))+-- | DSL accessor for the argument field of hydra.core.ApplicationType+applicationTypeArgument :: Typed.TypedTerm Core.ApplicationType -> Typed.TypedTerm Core.Type+applicationTypeArgument x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"),+        Core.projectionFieldName = (Core.Name "argument")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the function field of hydra.core.ApplicationType+applicationTypeFunction :: Typed.TypedTerm Core.ApplicationType -> Typed.TypedTerm Core.Type+applicationTypeFunction x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"),+        Core.projectionFieldName = (Core.Name "function")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the argument field of hydra.core.ApplicationType+applicationTypeWithArgument :: Typed.TypedTerm Core.ApplicationType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.ApplicationType+applicationTypeWithArgument original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"),+              Core.projectionFieldName = (Core.Name "function")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the function field of hydra.core.ApplicationType+applicationTypeWithFunction :: Typed.TypedTerm Core.ApplicationType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.ApplicationType+applicationTypeWithFunction original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"),+              Core.projectionFieldName = (Core.Name "argument")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the argument field of hydra.core.Application+applicationWithArgument :: Typed.TypedTerm Core.Application -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Application+applicationWithArgument original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Application"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Application"),+              Core.projectionFieldName = (Core.Name "function")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the function field of hydra.core.Application+applicationWithFunction :: Typed.TypedTerm Core.Application -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Application+applicationWithFunction original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Application"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Application"),+              Core.projectionFieldName = (Core.Name "argument")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.Binding+binding :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Maybe Core.TypeScheme) -> Typed.TypedTerm Core.Binding+binding name term typeScheme =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Binding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm term)},+        Core.Field {+          Core.fieldName = (Core.Name "typeScheme"),+          Core.fieldTerm = (Typed.unTypedTerm typeScheme)}]}))+-- | DSL accessor for the name field of hydra.core.Binding+bindingName :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Core.Name+bindingName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the term field of hydra.core.Binding+bindingTerm :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Core.Term+bindingTerm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+        Core.projectionFieldName = (Core.Name "term")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeScheme field of hydra.core.Binding+bindingTypeScheme :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Maybe Core.TypeScheme)+bindingTypeScheme x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+        Core.projectionFieldName = (Core.Name "typeScheme")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.core.Binding+bindingWithName :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Binding+bindingWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Binding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeScheme"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+              Core.projectionFieldName = (Core.Name "typeScheme")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the term field of hydra.core.Binding+bindingWithTerm :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Binding+bindingWithTerm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Binding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeScheme"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+              Core.projectionFieldName = (Core.Name "typeScheme")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeScheme field of hydra.core.Binding+bindingWithTypeScheme :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm (Maybe Core.TypeScheme) -> Typed.TypedTerm Core.Binding+bindingWithTypeScheme original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Binding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeScheme"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.core.CaseAlternative+caseAlternative :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.CaseAlternative+caseAlternative name handler =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseAlternative"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "handler"),+          Core.fieldTerm = (Typed.unTypedTerm handler)}]}))+-- | DSL accessor for the handler field of hydra.core.CaseAlternative+caseAlternativeHandler :: Typed.TypedTerm Core.CaseAlternative -> Typed.TypedTerm Core.Term+caseAlternativeHandler x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"),+        Core.projectionFieldName = (Core.Name "handler")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.core.CaseAlternative+caseAlternativeName :: Typed.TypedTerm Core.CaseAlternative -> Typed.TypedTerm Core.Name+caseAlternativeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the handler field of hydra.core.CaseAlternative+caseAlternativeWithHandler :: Typed.TypedTerm Core.CaseAlternative -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.CaseAlternative+caseAlternativeWithHandler original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseAlternative"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "handler"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.core.CaseAlternative+caseAlternativeWithName :: Typed.TypedTerm Core.CaseAlternative -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.CaseAlternative+caseAlternativeWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseAlternative"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "handler"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"),+              Core.projectionFieldName = (Core.Name "handler")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.CaseStatement+caseStatement :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm [Core.CaseAlternative] -> Typed.TypedTerm Core.CaseStatement+caseStatement typeName default_ cases =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm default_)},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))+-- | DSL accessor for the cases field of hydra.core.CaseStatement+caseStatementCases :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm [Core.CaseAlternative]+caseStatementCases x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+        Core.projectionFieldName = (Core.Name "cases")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the default field of hydra.core.CaseStatement+caseStatementDefault :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm (Maybe Core.Term)+caseStatementDefault x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+        Core.projectionFieldName = (Core.Name "default")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.core.CaseStatement+caseStatementTypeName :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm Core.Name+caseStatementTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the cases field of hydra.core.CaseStatement+caseStatementWithCases :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm [Core.CaseAlternative] -> Typed.TypedTerm Core.CaseStatement+caseStatementWithCases original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the default field of hydra.core.CaseStatement+caseStatementWithDefault :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Core.CaseStatement+caseStatementWithDefault original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+              Core.projectionFieldName = (Core.Name "cases")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeName field of hydra.core.CaseStatement+caseStatementWithTypeName :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.CaseStatement+caseStatementWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+              Core.projectionFieldName = (Core.Name "default")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+              Core.projectionFieldName = (Core.Name "cases")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.EitherType+eitherType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.EitherType+eitherType left right =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.EitherType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm left)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm right)}]}))+-- | DSL accessor for the left field of hydra.core.EitherType+eitherTypeLeft :: Typed.TypedTerm Core.EitherType -> Typed.TypedTerm Core.Type+eitherTypeLeft x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.EitherType"),+        Core.projectionFieldName = (Core.Name "left")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the right field of hydra.core.EitherType+eitherTypeRight :: Typed.TypedTerm Core.EitherType -> Typed.TypedTerm Core.Type+eitherTypeRight x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.EitherType"),+        Core.projectionFieldName = (Core.Name "right")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the left field of hydra.core.EitherType+eitherTypeWithLeft :: Typed.TypedTerm Core.EitherType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.EitherType+eitherTypeWithLeft original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.EitherType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.EitherType"),+              Core.projectionFieldName = (Core.Name "right")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the right field of hydra.core.EitherType+eitherTypeWithRight :: Typed.TypedTerm Core.EitherType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.EitherType+eitherTypeWithRight original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.EitherType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.EitherType"),+              Core.projectionFieldName = (Core.Name "left")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.core.Field+field :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Field+field name term =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Field"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm term)}]}))+-- | DSL accessor for the name field of hydra.core.Field+fieldName :: Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Name+fieldName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Field"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the term field of hydra.core.Field+fieldTerm :: Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Term+fieldTerm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Field"),+        Core.projectionFieldName = (Core.Name "term")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.core.FieldType+fieldType :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.FieldType+fieldType name type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FieldType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))+-- | DSL accessor for the name field of hydra.core.FieldType+fieldTypeName :: Typed.TypedTerm Core.FieldType -> Typed.TypedTerm Core.Name+fieldTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.FieldType"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.core.FieldType+fieldTypeType :: Typed.TypedTerm Core.FieldType -> Typed.TypedTerm Core.Type+fieldTypeType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.FieldType"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.core.FieldType+fieldTypeWithName :: Typed.TypedTerm Core.FieldType -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.FieldType+fieldTypeWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FieldType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.FieldType"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.core.FieldType+fieldTypeWithType :: Typed.TypedTerm Core.FieldType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.FieldType+fieldTypeWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FieldType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.FieldType"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.core.Field+fieldWithName :: Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Field+fieldWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Field"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Field"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the term field of hydra.core.Field+fieldWithTerm :: Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Field+fieldWithTerm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Field"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Field"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the float32 variant of hydra.core.FloatType+floatTypeFloat32 :: Typed.TypedTerm Core.FloatType+floatTypeFloat32 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float32"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the float64 variant of hydra.core.FloatType+floatTypeFloat64 :: Typed.TypedTerm Core.FloatType+floatTypeFloat64 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float64"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the float32 variant of hydra.core.FloatValue+floatValueFloat32 :: Typed.TypedTerm Float -> Typed.TypedTerm Core.FloatValue+floatValueFloat32 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float32"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the float64 variant of hydra.core.FloatValue+floatValueFloat64 :: Typed.TypedTerm Double -> Typed.TypedTerm Core.FloatValue+floatValueFloat64 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float64"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.core.ForallType+forallType :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.ForallType+forallType parameter body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ForallType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Typed.unTypedTerm parameter)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))+-- | DSL accessor for the body field of hydra.core.ForallType+forallTypeBody :: Typed.TypedTerm Core.ForallType -> Typed.TypedTerm Core.Type+forallTypeBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.ForallType"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the parameter field of hydra.core.ForallType+forallTypeParameter :: Typed.TypedTerm Core.ForallType -> Typed.TypedTerm Core.Name+forallTypeParameter x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.ForallType"),+        Core.projectionFieldName = (Core.Name "parameter")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.core.ForallType+forallTypeWithBody :: Typed.TypedTerm Core.ForallType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.ForallType+forallTypeWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ForallType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.ForallType"),+              Core.projectionFieldName = (Core.Name "parameter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the parameter field of hydra.core.ForallType+forallTypeWithParameter :: Typed.TypedTerm Core.ForallType -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.ForallType+forallTypeWithParameter original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ForallType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.ForallType"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.FunctionType+functionType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.FunctionType+functionType domain codomain =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FunctionType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm domain)},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Typed.unTypedTerm codomain)}]}))+-- | DSL accessor for the codomain field of hydra.core.FunctionType+functionTypeCodomain :: Typed.TypedTerm Core.FunctionType -> Typed.TypedTerm Core.Type+functionTypeCodomain x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"),+        Core.projectionFieldName = (Core.Name "codomain")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the domain field of hydra.core.FunctionType+functionTypeDomain :: Typed.TypedTerm Core.FunctionType -> Typed.TypedTerm Core.Type+functionTypeDomain x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"),+        Core.projectionFieldName = (Core.Name "domain")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the codomain field of hydra.core.FunctionType+functionTypeWithCodomain :: Typed.TypedTerm Core.FunctionType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.FunctionType+functionTypeWithCodomain original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FunctionType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"),+              Core.projectionFieldName = (Core.Name "domain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the domain field of hydra.core.FunctionType+functionTypeWithDomain :: Typed.TypedTerm Core.FunctionType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.FunctionType+functionTypeWithDomain original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FunctionType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"),+              Core.projectionFieldName = (Core.Name "codomain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.Injection+injection :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Injection+injection typeName field =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Injection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Typed.unTypedTerm field)}]}))+-- | DSL accessor for the field field of hydra.core.Injection+injectionField :: Typed.TypedTerm Core.Injection -> Typed.TypedTerm Core.Field+injectionField x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+        Core.projectionFieldName = (Core.Name "field")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.core.Injection+injectionTypeName :: Typed.TypedTerm Core.Injection -> Typed.TypedTerm Core.Name+injectionTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the field field of hydra.core.Injection+injectionWithField :: Typed.TypedTerm Core.Injection -> Typed.TypedTerm Core.Field -> Typed.TypedTerm Core.Injection+injectionWithField original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Injection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the typeName field of hydra.core.Injection+injectionWithTypeName :: Typed.TypedTerm Core.Injection -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Injection+injectionWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Injection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+              Core.projectionFieldName = (Core.Name "field")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the bigint variant of hydra.core.IntegerType+integerTypeBigint :: Typed.TypedTerm Core.IntegerType+integerTypeBigint =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "bigint"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the int16 variant of hydra.core.IntegerType+integerTypeInt16 :: Typed.TypedTerm Core.IntegerType+integerTypeInt16 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int16"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the int32 variant of hydra.core.IntegerType+integerTypeInt32 :: Typed.TypedTerm Core.IntegerType+integerTypeInt32 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int32"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the int64 variant of hydra.core.IntegerType+integerTypeInt64 :: Typed.TypedTerm Core.IntegerType+integerTypeInt64 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int64"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the int8 variant of hydra.core.IntegerType+integerTypeInt8 :: Typed.TypedTerm Core.IntegerType+integerTypeInt8 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int8"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the uint16 variant of hydra.core.IntegerType+integerTypeUint16 :: Typed.TypedTerm Core.IntegerType+integerTypeUint16 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint16"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the uint32 variant of hydra.core.IntegerType+integerTypeUint32 :: Typed.TypedTerm Core.IntegerType+integerTypeUint32 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint32"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the uint64 variant of hydra.core.IntegerType+integerTypeUint64 :: Typed.TypedTerm Core.IntegerType+integerTypeUint64 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint64"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the uint8 variant of hydra.core.IntegerType+integerTypeUint8 :: Typed.TypedTerm Core.IntegerType+integerTypeUint8 =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint8"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the bigint variant of hydra.core.IntegerValue+integerValueBigint :: Typed.TypedTerm Integer -> Typed.TypedTerm Core.IntegerValue+integerValueBigint x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "bigint"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the int16 variant of hydra.core.IntegerValue+integerValueInt16 :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Core.IntegerValue+integerValueInt16 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int16"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the int32 variant of hydra.core.IntegerValue+integerValueInt32 :: Typed.TypedTerm Int -> Typed.TypedTerm Core.IntegerValue+integerValueInt32 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int32"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the int64 variant of hydra.core.IntegerValue+integerValueInt64 :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Core.IntegerValue+integerValueInt64 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int64"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the int8 variant of hydra.core.IntegerValue+integerValueInt8 :: Typed.TypedTerm I.Int8 -> Typed.TypedTerm Core.IntegerValue+integerValueInt8 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int8"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the uint16 variant of hydra.core.IntegerValue+integerValueUint16 :: Typed.TypedTerm Int -> Typed.TypedTerm Core.IntegerValue+integerValueUint16 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint16"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the uint32 variant of hydra.core.IntegerValue+integerValueUint32 :: Typed.TypedTerm I.Int64 -> Typed.TypedTerm Core.IntegerValue+integerValueUint32 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint32"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the uint64 variant of hydra.core.IntegerValue+integerValueUint64 :: Typed.TypedTerm Integer -> Typed.TypedTerm Core.IntegerValue+integerValueUint64 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint64"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the uint8 variant of hydra.core.IntegerValue+integerValueUint8 :: Typed.TypedTerm I.Int16 -> Typed.TypedTerm Core.IntegerValue+integerValueUint8 x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "uint8"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.core.Lambda+lambda :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Lambda+lambda parameter domain body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Lambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Typed.unTypedTerm parameter)},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm domain)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))+-- | DSL accessor for the body field of hydra.core.Lambda+lambdaBody :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Core.Term+lambdaBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the domain field of hydra.core.Lambda+lambdaDomain :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm (Maybe Core.Type)+lambdaDomain x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+        Core.projectionFieldName = (Core.Name "domain")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the parameter field of hydra.core.Lambda+lambdaParameter :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Core.Name+lambdaParameter x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+        Core.projectionFieldName = (Core.Name "parameter")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.core.Lambda+lambdaWithBody :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Lambda+lambdaWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Lambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+              Core.projectionFieldName = (Core.Name "parameter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+              Core.projectionFieldName = (Core.Name "domain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the domain field of hydra.core.Lambda+lambdaWithDomain :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm Core.Lambda+lambdaWithDomain original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Lambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+              Core.projectionFieldName = (Core.Name "parameter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the parameter field of hydra.core.Lambda+lambdaWithParameter :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Lambda+lambdaWithParameter original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Lambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+              Core.projectionFieldName = (Core.Name "domain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.Let+let_ :: Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Let+let_ bindings body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Let"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Typed.unTypedTerm bindings)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))+-- | DSL accessor for the bindings field of hydra.core.Let+letBindings :: Typed.TypedTerm Core.Let -> Typed.TypedTerm [Core.Binding]+letBindings x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Let"),+        Core.projectionFieldName = (Core.Name "bindings")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body field of hydra.core.Let+letBody :: Typed.TypedTerm Core.Let -> Typed.TypedTerm Core.Term+letBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Let"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the bindings field of hydra.core.Let+letWithBindings :: Typed.TypedTerm Core.Let -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Let+letWithBindings original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Let"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Let"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the body field of hydra.core.Let+letWithBody :: Typed.TypedTerm Core.Let -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Let+letWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Let"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Let"),+              Core.projectionFieldName = (Core.Name "bindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the binary variant of hydra.core.Literal+literalBinary :: Typed.TypedTerm B.ByteString -> Typed.TypedTerm Core.Literal+literalBinary x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "binary"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the boolean variant of hydra.core.Literal+literalBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Core.Literal+literalBoolean x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "boolean"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the decimal variant of hydra.core.Literal+literalDecimal :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm Core.Literal+literalDecimal x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "decimal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the float variant of hydra.core.Literal+literalFloat :: Typed.TypedTerm Core.FloatValue -> Typed.TypedTerm Core.Literal+literalFloat x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the integer variant of hydra.core.Literal+literalInteger :: Typed.TypedTerm Core.IntegerValue -> Typed.TypedTerm Core.Literal+literalInteger x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "integer"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the string variant of hydra.core.Literal+literalString :: Typed.TypedTerm String -> Typed.TypedTerm Core.Literal+literalString x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "string"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the binary variant of hydra.core.LiteralType+literalTypeBinary :: Typed.TypedTerm Core.LiteralType+literalTypeBinary =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "binary"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the boolean variant of hydra.core.LiteralType+literalTypeBoolean :: Typed.TypedTerm Core.LiteralType+literalTypeBoolean =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "boolean"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the decimal variant of hydra.core.LiteralType+literalTypeDecimal :: Typed.TypedTerm Core.LiteralType+literalTypeDecimal =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "decimal"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the float variant of hydra.core.LiteralType+literalTypeFloat :: Typed.TypedTerm Core.FloatType -> Typed.TypedTerm Core.LiteralType+literalTypeFloat x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the integer variant of hydra.core.LiteralType+literalTypeInteger :: Typed.TypedTerm Core.IntegerType -> Typed.TypedTerm Core.LiteralType+literalTypeInteger x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "integer"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the string variant of hydra.core.LiteralType+literalTypeString :: Typed.TypedTerm Core.LiteralType+literalTypeString =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "string"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for hydra.core.MapType+mapType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.MapType+mapType keys values =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.MapType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = (Typed.unTypedTerm keys)},+        Core.Field {+          Core.fieldName = (Core.Name "values"),+          Core.fieldTerm = (Typed.unTypedTerm values)}]}))+-- | DSL accessor for the keys field of hydra.core.MapType+mapTypeKeys :: Typed.TypedTerm Core.MapType -> Typed.TypedTerm Core.Type+mapTypeKeys x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.MapType"),+        Core.projectionFieldName = (Core.Name "keys")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the values field of hydra.core.MapType+mapTypeValues :: Typed.TypedTerm Core.MapType -> Typed.TypedTerm Core.Type+mapTypeValues x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.MapType"),+        Core.projectionFieldName = (Core.Name "values")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the keys field of hydra.core.MapType+mapTypeWithKeys :: Typed.TypedTerm Core.MapType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.MapType+mapTypeWithKeys original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.MapType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "values"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.MapType"),+              Core.projectionFieldName = (Core.Name "values")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the values field of hydra.core.MapType+mapTypeWithValues :: Typed.TypedTerm Core.MapType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.MapType+mapTypeWithValues original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.MapType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.MapType"),+              Core.projectionFieldName = (Core.Name "keys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "values"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for the hydra.core.Name wrapper+name :: Typed.TypedTerm String -> Typed.TypedTerm Core.Name+name x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.core.PairType+pairType :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.PairType+pairType first second =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.PairType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "first"),+          Core.fieldTerm = (Typed.unTypedTerm first)},+        Core.Field {+          Core.fieldName = (Core.Name "second"),+          Core.fieldTerm = (Typed.unTypedTerm second)}]}))+-- | DSL accessor for the first field of hydra.core.PairType+pairTypeFirst :: Typed.TypedTerm Core.PairType -> Typed.TypedTerm Core.Type+pairTypeFirst x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.PairType"),+        Core.projectionFieldName = (Core.Name "first")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the second field of hydra.core.PairType+pairTypeSecond :: Typed.TypedTerm Core.PairType -> Typed.TypedTerm Core.Type+pairTypeSecond x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.PairType"),+        Core.projectionFieldName = (Core.Name "second")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the first field of hydra.core.PairType+pairTypeWithFirst :: Typed.TypedTerm Core.PairType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.PairType+pairTypeWithFirst original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.PairType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "first"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "second"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.PairType"),+              Core.projectionFieldName = (Core.Name "second")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the second field of hydra.core.PairType+pairTypeWithSecond :: Typed.TypedTerm Core.PairType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.PairType+pairTypeWithSecond original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.PairType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "first"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.PairType"),+              Core.projectionFieldName = (Core.Name "first")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "second"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.core.Projection+projection :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Projection+projection typeName fieldName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Projection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm fieldName)}]}))+-- | DSL accessor for the fieldName field of hydra.core.Projection+projectionFieldName :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Core.Name+projectionFieldName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Projection"),+        Core.projectionFieldName = (Core.Name "fieldName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.core.Projection+projectionTypeName :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Core.Name+projectionTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Projection"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the fieldName field of hydra.core.Projection+projectionWithFieldName :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Projection+projectionWithFieldName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Projection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Projection"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the typeName field of hydra.core.Projection+projectionWithTypeName :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Projection+projectionWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Projection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Projection"),+              Core.projectionFieldName = (Core.Name "fieldName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.core.Record+record :: Typed.TypedTerm Core.Name -> Typed.TypedTerm [Core.Field] -> Typed.TypedTerm Core.Record+record typeName fields =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Record"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)},+        Core.Field {+          Core.fieldName = (Core.Name "fields"),+          Core.fieldTerm = (Typed.unTypedTerm fields)}]}))+-- | DSL accessor for the fields field of hydra.core.Record+recordFields :: Typed.TypedTerm Core.Record -> Typed.TypedTerm [Core.Field]+recordFields x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Record"),+        Core.projectionFieldName = (Core.Name "fields")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.core.Record+recordTypeName :: Typed.TypedTerm Core.Record -> Typed.TypedTerm Core.Name+recordTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.Record"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the fields field of hydra.core.Record+recordWithFields :: Typed.TypedTerm Core.Record -> Typed.TypedTerm [Core.Field] -> Typed.TypedTerm Core.Record+recordWithFields original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Record"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Record"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "fields"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the typeName field of hydra.core.Record+recordWithTypeName :: Typed.TypedTerm Core.Record -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Record+recordWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Record"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "fields"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.Record"),+              Core.projectionFieldName = (Core.Name "fields")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the annotated variant of hydra.core.Term+termAnnotated :: Typed.TypedTerm Core.AnnotatedTerm -> Typed.TypedTerm Core.Term+termAnnotated x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotated"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the application variant of hydra.core.Term+termApplication :: Typed.TypedTerm Core.Application -> Typed.TypedTerm Core.Term+termApplication x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "application"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the cases variant of hydra.core.Term+termCases :: Typed.TypedTerm Core.CaseStatement -> Typed.TypedTerm Core.Term+termCases x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "cases"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the either variant of hydra.core.Term+termEither :: Typed.TypedTerm (Either Core.Term Core.Term) -> Typed.TypedTerm Core.Term+termEither x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "either"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the inject variant of hydra.core.Term+termInject :: Typed.TypedTerm Core.Injection -> Typed.TypedTerm Core.Term+termInject x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "inject"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the lambda variant of hydra.core.Term+termLambda :: Typed.TypedTerm Core.Lambda -> Typed.TypedTerm Core.Term+termLambda x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambda"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the let variant of hydra.core.Term+termLet :: Typed.TypedTerm Core.Let -> Typed.TypedTerm Core.Term+termLet x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "let"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the list variant of hydra.core.Term+termList :: Typed.TypedTerm [Core.Term] -> Typed.TypedTerm Core.Term+termList x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "list"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the literal variant of hydra.core.Term+termLiteral :: Typed.TypedTerm Core.Literal -> Typed.TypedTerm Core.Term+termLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the map variant of hydra.core.Term+termMap :: Typed.TypedTerm (M.Map Core.Term Core.Term) -> Typed.TypedTerm Core.Term+termMap x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "map"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the optional variant of hydra.core.Term+termOptional :: Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Core.Term+termOptional x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optional"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the pair variant of hydra.core.Term+termPair :: Typed.TypedTerm (Core.Term, Core.Term) -> Typed.TypedTerm Core.Term+termPair x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pair"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the project variant of hydra.core.Term+termProject :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Core.Term+termProject x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "project"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the record variant of hydra.core.Term+termRecord :: Typed.TypedTerm Core.Record -> Typed.TypedTerm Core.Term+termRecord x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "record"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the set variant of hydra.core.Term+termSet :: Typed.TypedTerm (S.Set Core.Term) -> Typed.TypedTerm Core.Term+termSet x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "set"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the typeApplication variant of hydra.core.Term+termTypeApplication :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Term+termTypeApplication x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeApplication"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the typeLambda variant of hydra.core.Term+termTypeLambda :: Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Core.Term+termTypeLambda x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeLambda"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unit variant of hydra.core.Term+termUnit :: Typed.TypedTerm Core.Term+termUnit =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unit"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the unwrap variant of hydra.core.Term+termUnwrap :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term+termUnwrap x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unwrap"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the variable variant of hydra.core.Term+termVariable :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term+termVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "variable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the wrap variant of hydra.core.Term+termWrap :: Typed.TypedTerm Core.WrappedTerm -> Typed.TypedTerm Core.Term+termWrap x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrap"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the annotated variant of hydra.core.Type+typeAnnotated :: Typed.TypedTerm Core.AnnotatedType -> Typed.TypedTerm Core.Type+typeAnnotated x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotated"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the application variant of hydra.core.Type+typeApplication :: Typed.TypedTerm Core.ApplicationType -> Typed.TypedTerm Core.Type+typeApplication x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "application"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.core.TypeApplicationTerm+typeApplicationTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.TypeApplicationTerm+typeApplicationTerm body type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))+-- | DSL accessor for the body field of hydra.core.TypeApplicationTerm+typeApplicationTermBody :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Term+typeApplicationTermBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.core.TypeApplicationTerm+typeApplicationTermType :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Type+typeApplicationTermType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.core.TypeApplicationTerm+typeApplicationTermWithBody :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.TypeApplicationTerm+typeApplicationTermWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.core.TypeApplicationTerm+typeApplicationTermWithType :: Typed.TypedTerm Core.TypeApplicationTerm -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.TypeApplicationTerm+typeApplicationTermWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the simple variant of hydra.core.TypeClassConstraint+typeClassConstraintSimple :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.TypeClassConstraint+typeClassConstraintSimple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.TypeClassConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "simple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the either variant of hydra.core.Type+typeEither :: Typed.TypedTerm Core.EitherType -> Typed.TypedTerm Core.Type+typeEither x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "either"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the forall variant of hydra.core.Type+typeForall :: Typed.TypedTerm Core.ForallType -> Typed.TypedTerm Core.Type+typeForall x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "forall"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the function variant of hydra.core.Type+typeFunction :: Typed.TypedTerm Core.FunctionType -> Typed.TypedTerm Core.Type+typeFunction x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "function"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.core.TypeLambda+typeLambda :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.TypeLambda+typeLambda parameter body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Typed.unTypedTerm parameter)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))+-- | DSL accessor for the body field of hydra.core.TypeLambda+typeLambdaBody :: Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Core.Term+typeLambdaBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the parameter field of hydra.core.TypeLambda+typeLambdaParameter :: Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Core.Name+typeLambdaParameter x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"),+        Core.projectionFieldName = (Core.Name "parameter")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.core.TypeLambda+typeLambdaWithBody :: Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.TypeLambda+typeLambdaWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"),+              Core.projectionFieldName = (Core.Name "parameter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the parameter field of hydra.core.TypeLambda+typeLambdaWithParameter :: Typed.TypedTerm Core.TypeLambda -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.TypeLambda+typeLambdaWithParameter original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the list variant of hydra.core.Type+typeList :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+typeList x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "list"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the literal variant of hydra.core.Type+typeLiteral :: Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm Core.Type+typeLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the map variant of hydra.core.Type+typeMap :: Typed.TypedTerm Core.MapType -> Typed.TypedTerm Core.Type+typeMap x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "map"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the optional variant of hydra.core.Type+typeOptional :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+typeOptional x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optional"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the pair variant of hydra.core.Type+typePair :: Typed.TypedTerm Core.PairType -> Typed.TypedTerm Core.Type+typePair x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pair"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the record variant of hydra.core.Type+typeRecord :: Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm Core.Type+typeRecord x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "record"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.core.TypeScheme+typeScheme :: Typed.TypedTerm [Core.Name] -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Maybe (M.Map Core.Name Core.TypeVariableConstraints)) -> Typed.TypedTerm Core.TypeScheme+typeScheme variables body constraints =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Typed.unTypedTerm variables)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm constraints)}]}))+-- | DSL accessor for the body field of hydra.core.TypeScheme+typeSchemeBody :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Core.Type+typeSchemeBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the constraints field of hydra.core.TypeScheme+typeSchemeConstraints :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm (Maybe (M.Map Core.Name Core.TypeVariableConstraints))+typeSchemeConstraints x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+        Core.projectionFieldName = (Core.Name "constraints")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the variables field of hydra.core.TypeScheme+typeSchemeVariables :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm [Core.Name]+typeSchemeVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+        Core.projectionFieldName = (Core.Name "variables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.core.TypeScheme+typeSchemeWithBody :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.TypeScheme+typeSchemeWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+              Core.projectionFieldName = (Core.Name "variables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the constraints field of hydra.core.TypeScheme+typeSchemeWithConstraints :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm (Maybe (M.Map Core.Name Core.TypeVariableConstraints)) -> Typed.TypedTerm Core.TypeScheme+typeSchemeWithConstraints original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+              Core.projectionFieldName = (Core.Name "variables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the variables field of hydra.core.TypeScheme+typeSchemeWithVariables :: Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm Core.TypeScheme+typeSchemeWithVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the set variant of hydra.core.Type+typeSet :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+typeSet x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "set"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the union variant of hydra.core.Type+typeUnion :: Typed.TypedTerm [Core.FieldType] -> Typed.TypedTerm Core.Type+typeUnion x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "union"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unit variant of hydra.core.Type+typeUnit :: Typed.TypedTerm Core.Type+typeUnit =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unit"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the variable variant of hydra.core.Type+typeVariable :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Type+typeVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "variable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.core.TypeVariableConstraints+typeVariableConstraints :: Typed.TypedTerm [Core.TypeClassConstraint] -> Typed.TypedTerm Core.TypeVariableConstraints+typeVariableConstraints classes =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeVariableConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "classes"),+          Core.fieldTerm = (Typed.unTypedTerm classes)}]}))+-- | DSL accessor for the classes field of hydra.core.TypeVariableConstraints+typeVariableConstraintsClasses :: Typed.TypedTerm Core.TypeVariableConstraints -> Typed.TypedTerm [Core.TypeClassConstraint]+typeVariableConstraintsClasses x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.TypeVariableConstraints"),+        Core.projectionFieldName = (Core.Name "classes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the classes field of hydra.core.TypeVariableConstraints+typeVariableConstraintsWithClasses :: Typed.TypedTerm Core.TypeVariableConstraints -> Typed.TypedTerm [Core.TypeClassConstraint] -> Typed.TypedTerm Core.TypeVariableConstraints+typeVariableConstraintsWithClasses original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeVariableConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "classes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the void variant of hydra.core.Type+typeVoid :: Typed.TypedTerm Core.Type+typeVoid =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "void"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the wrap variant of hydra.core.Type+typeWrap :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+typeWrap x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrap"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL accessor for the body of hydra.core.Name+unName :: Typed.TypedTerm Core.Name -> Typed.TypedTerm String+unName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.core.WrappedTerm+wrappedTerm :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.WrappedTerm+wrappedTerm typeName body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))+-- | DSL accessor for the body field of hydra.core.WrappedTerm+wrappedTermBody :: Typed.TypedTerm Core.WrappedTerm -> Typed.TypedTerm Core.Term+wrappedTermBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.core.WrappedTerm+wrappedTermTypeName :: Typed.TypedTerm Core.WrappedTerm -> Typed.TypedTerm Core.Name+wrappedTermTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.core.WrappedTerm+wrappedTermWithBody :: Typed.TypedTerm Core.WrappedTerm -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.WrappedTerm+wrappedTermWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the typeName field of hydra.core.WrappedTerm+wrappedTermWithTypeName :: Typed.TypedTerm Core.WrappedTerm -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.WrappedTerm+wrappedTermWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+ src/main/haskell/Hydra/Dsl/Error/Checking.hs view
@@ -0,0 +1,821 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.error.checking++module Hydra.Dsl.Error.Checking where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Paths as Paths+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | DSL injection for the incorrectUnification variant of hydra.error.checking.CheckingError+checkingErrorIncorrectUnification :: Typed.TypedTerm Checking.IncorrectUnificationError -> Typed.TypedTerm Checking.CheckingError+checkingErrorIncorrectUnification x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "incorrectUnification"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the notAForallType variant of hydra.error.checking.CheckingError+checkingErrorNotAForallType :: Typed.TypedTerm Checking.NotAForallTypeError -> Typed.TypedTerm Checking.CheckingError+checkingErrorNotAForallType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "notAForallType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the notAFunctionType variant of hydra.error.checking.CheckingError+checkingErrorNotAFunctionType :: Typed.TypedTerm Checking.NotAFunctionTypeError -> Typed.TypedTerm Checking.CheckingError+checkingErrorNotAFunctionType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "notAFunctionType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the other variant of hydra.error.checking.CheckingError+checkingErrorOther :: Typed.TypedTerm Checking.OtherCheckingError -> Typed.TypedTerm Checking.CheckingError+checkingErrorOther x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "other"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the typeArityMismatch variant of hydra.error.checking.CheckingError+checkingErrorTypeArityMismatch :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Checking.CheckingError+checkingErrorTypeArityMismatch x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeArityMismatch"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the typeMismatch variant of hydra.error.checking.CheckingError+checkingErrorTypeMismatch :: Typed.TypedTerm Checking.TypeMismatchError -> Typed.TypedTerm Checking.CheckingError+checkingErrorTypeMismatch x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeMismatch"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unboundTypeVariables variant of hydra.error.checking.CheckingError+checkingErrorUnboundTypeVariables :: Typed.TypedTerm Checking.UnboundTypeVariablesError -> Typed.TypedTerm Checking.CheckingError+checkingErrorUnboundTypeVariables x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unboundTypeVariables"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedTermVariable variant of hydra.error.checking.CheckingError+checkingErrorUndefinedTermVariable :: Typed.TypedTerm Checking.UndefinedTermVariableCheckingError -> Typed.TypedTerm Checking.CheckingError+checkingErrorUndefinedTermVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedTermVariable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unequalTypes variant of hydra.error.checking.CheckingError+checkingErrorUnequalTypes :: Typed.TypedTerm Checking.UnequalTypesError -> Typed.TypedTerm Checking.CheckingError+checkingErrorUnequalTypes x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unequalTypes"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unsupportedTermVariant variant of hydra.error.checking.CheckingError+checkingErrorUnsupportedTermVariant :: Typed.TypedTerm Checking.UnsupportedTermVariantError -> Typed.TypedTerm Checking.CheckingError+checkingErrorUnsupportedTermVariant x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unsupportedTermVariant"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the untypedLambda variant of hydra.error.checking.CheckingError+checkingErrorUntypedLambda :: Typed.TypedTerm Checking.UntypedLambdaError -> Typed.TypedTerm Checking.CheckingError+checkingErrorUntypedLambda x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "untypedLambda"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the untypedLetBinding variant of hydra.error.checking.CheckingError+checkingErrorUntypedLetBinding :: Typed.TypedTerm Checking.UntypedLetBindingError -> Typed.TypedTerm Checking.CheckingError+checkingErrorUntypedLetBinding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "untypedLetBinding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the untypedTermVariable variant of hydra.error.checking.CheckingError+checkingErrorUntypedTermVariable :: Typed.TypedTerm Checking.UntypedTermVariableCheckingError -> Typed.TypedTerm Checking.CheckingError+checkingErrorUntypedTermVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "untypedTermVariable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.error.checking.IncorrectUnificationError+incorrectUnificationError :: Typed.TypedTerm Typing.TypeSubst -> Typed.TypedTerm Checking.IncorrectUnificationError+incorrectUnificationError substitution =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "substitution"),+          Core.fieldTerm = (Typed.unTypedTerm substitution)}]}))+-- | DSL accessor for the substitution field of hydra.error.checking.IncorrectUnificationError+incorrectUnificationErrorSubstitution :: Typed.TypedTerm Checking.IncorrectUnificationError -> Typed.TypedTerm Typing.TypeSubst+incorrectUnificationErrorSubstitution x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"),+        Core.projectionFieldName = (Core.Name "substitution")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the substitution field of hydra.error.checking.IncorrectUnificationError+incorrectUnificationErrorWithSubstitution :: Typed.TypedTerm Checking.IncorrectUnificationError -> Typed.TypedTerm Typing.TypeSubst -> Typed.TypedTerm Checking.IncorrectUnificationError+incorrectUnificationErrorWithSubstitution original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "substitution"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.checking.NotAForallTypeError+notAForallTypeError :: Typed.TypedTerm Core.Type -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Checking.NotAForallTypeError+notAForallTypeError type_ typeArguments =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))+-- | DSL accessor for the type field of hydra.error.checking.NotAForallTypeError+notAForallTypeErrorType :: Typed.TypedTerm Checking.NotAForallTypeError -> Typed.TypedTerm Core.Type+notAForallTypeErrorType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeArguments field of hydra.error.checking.NotAForallTypeError+notAForallTypeErrorTypeArguments :: Typed.TypedTerm Checking.NotAForallTypeError -> Typed.TypedTerm [Core.Type]+notAForallTypeErrorTypeArguments x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+        Core.projectionFieldName = (Core.Name "typeArguments")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the type field of hydra.error.checking.NotAForallTypeError+notAForallTypeErrorWithType :: Typed.TypedTerm Checking.NotAForallTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.NotAForallTypeError+notAForallTypeErrorWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+              Core.projectionFieldName = (Core.Name "typeArguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeArguments field of hydra.error.checking.NotAForallTypeError+notAForallTypeErrorWithTypeArguments :: Typed.TypedTerm Checking.NotAForallTypeError -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Checking.NotAForallTypeError+notAForallTypeErrorWithTypeArguments original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.checking.NotAFunctionTypeError+notAFunctionTypeError :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.NotAFunctionTypeError+notAFunctionTypeError type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))+-- | DSL accessor for the type field of hydra.error.checking.NotAFunctionTypeError+notAFunctionTypeErrorType :: Typed.TypedTerm Checking.NotAFunctionTypeError -> Typed.TypedTerm Core.Type+notAFunctionTypeErrorType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the type field of hydra.error.checking.NotAFunctionTypeError+notAFunctionTypeErrorWithType :: Typed.TypedTerm Checking.NotAFunctionTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.NotAFunctionTypeError+notAFunctionTypeErrorWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.checking.OtherCheckingError+otherCheckingError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm String -> Typed.TypedTerm Checking.OtherCheckingError+otherCheckingError path message =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm message)}]}))+-- | DSL accessor for the message field of hydra.error.checking.OtherCheckingError+otherCheckingErrorMessage :: Typed.TypedTerm Checking.OtherCheckingError -> Typed.TypedTerm String+otherCheckingErrorMessage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+        Core.projectionFieldName = (Core.Name "message")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the path field of hydra.error.checking.OtherCheckingError+otherCheckingErrorPath :: Typed.TypedTerm Checking.OtherCheckingError -> Typed.TypedTerm Paths.SubtermPath+otherCheckingErrorPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the message field of hydra.error.checking.OtherCheckingError+otherCheckingErrorWithMessage :: Typed.TypedTerm Checking.OtherCheckingError -> Typed.TypedTerm String -> Typed.TypedTerm Checking.OtherCheckingError+otherCheckingErrorWithMessage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the path field of hydra.error.checking.OtherCheckingError+otherCheckingErrorWithPath :: Typed.TypedTerm Checking.OtherCheckingError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Checking.OtherCheckingError+otherCheckingErrorWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.checking.TypeArityMismatchError+typeArityMismatchError :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Checking.TypeArityMismatchError+typeArityMismatchError type_ expectedArity actualArity typeArguments =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "expectedArity"),+          Core.fieldTerm = (Typed.unTypedTerm expectedArity)},+        Core.Field {+          Core.fieldName = (Core.Name "actualArity"),+          Core.fieldTerm = (Typed.unTypedTerm actualArity)},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Typed.unTypedTerm typeArguments)}]}))+-- | DSL accessor for the actualArity field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorActualArity :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Int+typeArityMismatchErrorActualArity x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+        Core.projectionFieldName = (Core.Name "actualArity")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the expectedArity field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorExpectedArity :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Int+typeArityMismatchErrorExpectedArity x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+        Core.projectionFieldName = (Core.Name "expectedArity")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorType :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Core.Type+typeArityMismatchErrorType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeArguments field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorTypeArguments :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm [Core.Type]+typeArityMismatchErrorTypeArguments x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+        Core.projectionFieldName = (Core.Name "typeArguments")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the actualArity field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorWithActualArity :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Int -> Typed.TypedTerm Checking.TypeArityMismatchError+typeArityMismatchErrorWithActualArity original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expectedArity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "expectedArity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actualArity"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "typeArguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the expectedArity field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorWithExpectedArity :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Int -> Typed.TypedTerm Checking.TypeArityMismatchError+typeArityMismatchErrorWithExpectedArity original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expectedArity"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "actualArity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "actualArity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "typeArguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorWithType :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.TypeArityMismatchError+typeArityMismatchErrorWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expectedArity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "expectedArity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actualArity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "actualArity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "typeArguments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeArguments field of hydra.error.checking.TypeArityMismatchError+typeArityMismatchErrorWithTypeArguments :: Typed.TypedTerm Checking.TypeArityMismatchError -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Checking.TypeArityMismatchError+typeArityMismatchErrorWithTypeArguments original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expectedArity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "expectedArity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actualArity"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+              Core.projectionFieldName = (Core.Name "actualArity")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.checking.TypeMismatchError+typeMismatchError :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.TypeMismatchError+typeMismatchError expectedType actualType =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (Typed.unTypedTerm expectedType)},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Typed.unTypedTerm actualType)}]}))+-- | DSL accessor for the actualType field of hydra.error.checking.TypeMismatchError+typeMismatchErrorActualType :: Typed.TypedTerm Checking.TypeMismatchError -> Typed.TypedTerm Core.Type+typeMismatchErrorActualType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+        Core.projectionFieldName = (Core.Name "actualType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the expectedType field of hydra.error.checking.TypeMismatchError+typeMismatchErrorExpectedType :: Typed.TypedTerm Checking.TypeMismatchError -> Typed.TypedTerm Core.Type+typeMismatchErrorExpectedType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+        Core.projectionFieldName = (Core.Name "expectedType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the actualType field of hydra.error.checking.TypeMismatchError+typeMismatchErrorWithActualType :: Typed.TypedTerm Checking.TypeMismatchError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.TypeMismatchError+typeMismatchErrorWithActualType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+              Core.projectionFieldName = (Core.Name "expectedType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the expectedType field of hydra.error.checking.TypeMismatchError+typeMismatchErrorWithExpectedType :: Typed.TypedTerm Checking.TypeMismatchError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.TypeMismatchError+typeMismatchErrorWithExpectedType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+              Core.projectionFieldName = (Core.Name "actualType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesError :: Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.UnboundTypeVariablesError+unboundTypeVariablesError variables type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Typed.unTypedTerm variables)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))+-- | DSL accessor for the type field of hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesErrorType :: Typed.TypedTerm Checking.UnboundTypeVariablesError -> Typed.TypedTerm Core.Type+unboundTypeVariablesErrorType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the variables field of hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesErrorVariables :: Typed.TypedTerm Checking.UnboundTypeVariablesError -> Typed.TypedTerm (S.Set Core.Name)+unboundTypeVariablesErrorVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+        Core.projectionFieldName = (Core.Name "variables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the type field of hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesErrorWithType :: Typed.TypedTerm Checking.UnboundTypeVariablesError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Checking.UnboundTypeVariablesError+unboundTypeVariablesErrorWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+              Core.projectionFieldName = (Core.Name "variables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the variables field of hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesErrorWithVariables :: Typed.TypedTerm Checking.UnboundTypeVariablesError -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Checking.UnboundTypeVariablesError+unboundTypeVariablesErrorWithVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingError path name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the name field of hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorName :: Typed.TypedTerm Checking.UndefinedTermVariableCheckingError -> Typed.TypedTerm Core.Name+undefinedTermVariableCheckingErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the path field of hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorPath :: Typed.TypedTerm Checking.UndefinedTermVariableCheckingError -> Typed.TypedTerm Paths.SubtermPath+undefinedTermVariableCheckingErrorPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorWithName :: Typed.TypedTerm Checking.UndefinedTermVariableCheckingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the path field of hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorWithPath :: Typed.TypedTerm Checking.UndefinedTermVariableCheckingError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingErrorWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.checking.UnequalTypesError+unequalTypesError :: Typed.TypedTerm [Core.Type] -> Typed.TypedTerm String -> Typed.TypedTerm Checking.UnequalTypesError+unequalTypesError types description =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Typed.unTypedTerm types)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)}]}))+-- | DSL accessor for the description field of hydra.error.checking.UnequalTypesError+unequalTypesErrorDescription :: Typed.TypedTerm Checking.UnequalTypesError -> Typed.TypedTerm String+unequalTypesErrorDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the types field of hydra.error.checking.UnequalTypesError+unequalTypesErrorTypes :: Typed.TypedTerm Checking.UnequalTypesError -> Typed.TypedTerm [Core.Type]+unequalTypesErrorTypes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+        Core.projectionFieldName = (Core.Name "types")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the description field of hydra.error.checking.UnequalTypesError+unequalTypesErrorWithDescription :: Typed.TypedTerm Checking.UnequalTypesError -> Typed.TypedTerm String -> Typed.TypedTerm Checking.UnequalTypesError+unequalTypesErrorWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+              Core.projectionFieldName = (Core.Name "types")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the types field of hydra.error.checking.UnequalTypesError+unequalTypesErrorWithTypes :: Typed.TypedTerm Checking.UnequalTypesError -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm Checking.UnequalTypesError+unequalTypesErrorWithTypes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.checking.UnsupportedTermVariantError+unsupportedTermVariantError :: Typed.TypedTerm Variants.TermVariant -> Typed.TypedTerm Checking.UnsupportedTermVariantError+unsupportedTermVariantError termVariant =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "termVariant"),+          Core.fieldTerm = (Typed.unTypedTerm termVariant)}]}))+-- | DSL accessor for the termVariant field of hydra.error.checking.UnsupportedTermVariantError+unsupportedTermVariantErrorTermVariant :: Typed.TypedTerm Checking.UnsupportedTermVariantError -> Typed.TypedTerm Variants.TermVariant+unsupportedTermVariantErrorTermVariant x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"),+        Core.projectionFieldName = (Core.Name "termVariant")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the termVariant field of hydra.error.checking.UnsupportedTermVariantError+unsupportedTermVariantErrorWithTermVariant :: Typed.TypedTerm Checking.UnsupportedTermVariantError -> Typed.TypedTerm Variants.TermVariant -> Typed.TypedTerm Checking.UnsupportedTermVariantError+unsupportedTermVariantErrorWithTermVariant original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "termVariant"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.checking.UntypedLambdaError+untypedLambdaError :: Typed.TypedTerm Checking.UntypedLambdaError+untypedLambdaError =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"),+      Core.recordFields = []}))+-- | DSL constructor for hydra.error.checking.UntypedLetBindingError+untypedLetBindingError :: Typed.TypedTerm Core.Binding -> Typed.TypedTerm Checking.UntypedLetBindingError+untypedLetBindingError binding =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "binding"),+          Core.fieldTerm = (Typed.unTypedTerm binding)}]}))+-- | DSL accessor for the binding field of hydra.error.checking.UntypedLetBindingError+untypedLetBindingErrorBinding :: Typed.TypedTerm Checking.UntypedLetBindingError -> Typed.TypedTerm Core.Binding+untypedLetBindingErrorBinding x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"),+        Core.projectionFieldName = (Core.Name "binding")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the binding field of hydra.error.checking.UntypedLetBindingError+untypedLetBindingErrorWithBinding :: Typed.TypedTerm Checking.UntypedLetBindingError -> Typed.TypedTerm Core.Binding -> Typed.TypedTerm Checking.UntypedLetBindingError+untypedLetBindingErrorWithBinding original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "binding"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingError path name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the name field of hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorName :: Typed.TypedTerm Checking.UntypedTermVariableCheckingError -> Typed.TypedTerm Core.Name+untypedTermVariableCheckingErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the path field of hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorPath :: Typed.TypedTerm Checking.UntypedTermVariableCheckingError -> Typed.TypedTerm Paths.SubtermPath+untypedTermVariableCheckingErrorPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorWithName :: Typed.TypedTerm Checking.UntypedTermVariableCheckingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the path field of hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorWithPath :: Typed.TypedTerm Checking.UntypedTermVariableCheckingError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingErrorWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+ src/main/haskell/Hydra/Dsl/Error/Core.hs view
@@ -0,0 +1,2370 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.error.core++module Hydra.Dsl.Error.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Paths as Paths+import qualified Hydra.Typed as Typed+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL constructor for hydra.error.core.ConstantConditionError+constantConditionError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Bool -> Typed.TypedTerm ErrorCore.ConstantConditionError+constantConditionError location value =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm value)}]}))+-- | DSL accessor for the location field of hydra.error.core.ConstantConditionError+constantConditionErrorLocation :: Typed.TypedTerm ErrorCore.ConstantConditionError -> Typed.TypedTerm Paths.SubtermPath+constantConditionErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the value field of hydra.error.core.ConstantConditionError+constantConditionErrorValue :: Typed.TypedTerm ErrorCore.ConstantConditionError -> Typed.TypedTerm Bool+constantConditionErrorValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+        Core.projectionFieldName = (Core.Name "value")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.ConstantConditionError+constantConditionErrorWithLocation :: Typed.TypedTerm ErrorCore.ConstantConditionError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.ConstantConditionError+constantConditionErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+              Core.projectionFieldName = (Core.Name "value")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the value field of hydra.error.core.ConstantConditionError+constantConditionErrorWithValue :: Typed.TypedTerm ErrorCore.ConstantConditionError -> Typed.TypedTerm Bool -> Typed.TypedTerm ErrorCore.ConstantConditionError+constantConditionErrorWithValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.DuplicateBindingError+duplicateBindingError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateBindingError+duplicateBindingError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.DuplicateBindingError+duplicateBindingErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm Paths.SubtermPath+duplicateBindingErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.DuplicateBindingError+duplicateBindingErrorName :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm Core.Name+duplicateBindingErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.DuplicateBindingError+duplicateBindingErrorWithLocation :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.DuplicateBindingError+duplicateBindingErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.DuplicateBindingError+duplicateBindingErrorWithName :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateBindingError+duplicateBindingErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.DuplicateFieldError+duplicateFieldError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateFieldError+duplicateFieldError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.DuplicateFieldError+duplicateFieldErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm Paths.SubtermPath+duplicateFieldErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.DuplicateFieldError+duplicateFieldErrorName :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm Core.Name+duplicateFieldErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.DuplicateFieldError+duplicateFieldErrorWithLocation :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.DuplicateFieldError+duplicateFieldErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.DuplicateFieldError+duplicateFieldErrorWithName :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateFieldError+duplicateFieldErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath+duplicateRecordTypeFieldNamesErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorName :: Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError -> Typed.TypedTerm Core.Name+duplicateRecordTypeFieldNamesErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorWithLocation :: Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorWithName :: Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorLocation :: Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath+duplicateUnionTypeFieldNamesErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorName :: Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError -> Typed.TypedTerm Core.Name+duplicateUnionTypeFieldNamesErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorWithLocation :: Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorWithName :: Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.EmptyCaseStatementError+emptyCaseStatementError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.EmptyCaseStatementError+emptyCaseStatementError location typeName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)}]}))+-- | DSL accessor for the location field of hydra.error.core.EmptyCaseStatementError+emptyCaseStatementErrorLocation :: Typed.TypedTerm ErrorCore.EmptyCaseStatementError -> Typed.TypedTerm Paths.SubtermPath+emptyCaseStatementErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.error.core.EmptyCaseStatementError+emptyCaseStatementErrorTypeName :: Typed.TypedTerm ErrorCore.EmptyCaseStatementError -> Typed.TypedTerm Core.Name+emptyCaseStatementErrorTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.EmptyCaseStatementError+emptyCaseStatementErrorWithLocation :: Typed.TypedTerm ErrorCore.EmptyCaseStatementError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyCaseStatementError+emptyCaseStatementErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeName field of hydra.error.core.EmptyCaseStatementError+emptyCaseStatementErrorWithTypeName :: Typed.TypedTerm ErrorCore.EmptyCaseStatementError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.EmptyCaseStatementError+emptyCaseStatementErrorWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.EmptyLetBindingsError+emptyLetBindingsError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyLetBindingsError+emptyLetBindingsError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.EmptyLetBindingsError+emptyLetBindingsErrorLocation :: Typed.TypedTerm ErrorCore.EmptyLetBindingsError -> Typed.TypedTerm Paths.SubtermPath+emptyLetBindingsErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.EmptyLetBindingsError+emptyLetBindingsErrorWithLocation :: Typed.TypedTerm ErrorCore.EmptyLetBindingsError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyLetBindingsError+emptyLetBindingsErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.EmptyRecordTypeError+emptyRecordTypeError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyRecordTypeError+emptyRecordTypeError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.EmptyRecordTypeError+emptyRecordTypeErrorLocation :: Typed.TypedTerm ErrorCore.EmptyRecordTypeError -> Typed.TypedTerm Paths.SubtermPath+emptyRecordTypeErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.EmptyRecordTypeError+emptyRecordTypeErrorWithLocation :: Typed.TypedTerm ErrorCore.EmptyRecordTypeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyRecordTypeError+emptyRecordTypeErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.EmptyTermAnnotationError+emptyTermAnnotationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyTermAnnotationError+emptyTermAnnotationError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.EmptyTermAnnotationError+emptyTermAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath+emptyTermAnnotationErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.EmptyTermAnnotationError+emptyTermAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.EmptyTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyTermAnnotationError+emptyTermAnnotationErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.EmptyTypeAnnotationError+emptyTypeAnnotationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyTypeAnnotationError+emptyTypeAnnotationError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.EmptyTypeAnnotationError+emptyTypeAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath+emptyTypeAnnotationErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.EmptyTypeAnnotationError+emptyTypeAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.EmptyTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyTypeAnnotationError+emptyTypeAnnotationErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.EmptyTypeNameInTermError+emptyTypeNameInTermError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyTypeNameInTermError+emptyTypeNameInTermError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.EmptyTypeNameInTermError+emptyTypeNameInTermErrorLocation :: Typed.TypedTerm ErrorCore.EmptyTypeNameInTermError -> Typed.TypedTerm Paths.SubtermPath+emptyTypeNameInTermErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.EmptyTypeNameInTermError+emptyTypeNameInTermErrorWithLocation :: Typed.TypedTerm ErrorCore.EmptyTypeNameInTermError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyTypeNameInTermError+emptyTypeNameInTermErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.EmptyUnionTypeError+emptyUnionTypeError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyUnionTypeError+emptyUnionTypeError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.EmptyUnionTypeError+emptyUnionTypeErrorLocation :: Typed.TypedTerm ErrorCore.EmptyUnionTypeError -> Typed.TypedTerm Paths.SubtermPath+emptyUnionTypeErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.EmptyUnionTypeError+emptyUnionTypeErrorWithLocation :: Typed.TypedTerm ErrorCore.EmptyUnionTypeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.EmptyUnionTypeError+emptyUnionTypeErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidForallParameterNameError+invalidForallParameterNameError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidForallParameterNameError -> Typed.TypedTerm Paths.SubtermPath+invalidForallParameterNameErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameErrorName :: Typed.TypedTerm ErrorCore.InvalidForallParameterNameError -> Typed.TypedTerm Core.Name+invalidForallParameterNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameErrorWithLocation :: Typed.TypedTerm ErrorCore.InvalidForallParameterNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.InvalidForallParameterNameError+invalidForallParameterNameErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameErrorWithName :: Typed.TypedTerm ErrorCore.InvalidForallParameterNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidForallParameterNameError+invalidForallParameterNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError+invalidLambdaParameterNameError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath+invalidLambdaParameterNameErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorName :: Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError -> Typed.TypedTerm Core.Name+invalidLambdaParameterNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorWithLocation :: Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorWithName :: Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError+invalidLambdaParameterNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidLetBindingNameError+invalidLetBindingNameError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidLetBindingNameError -> Typed.TypedTerm Paths.SubtermPath+invalidLetBindingNameErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameErrorName :: Typed.TypedTerm ErrorCore.InvalidLetBindingNameError -> Typed.TypedTerm Core.Name+invalidLetBindingNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameErrorWithLocation :: Typed.TypedTerm ErrorCore.InvalidLetBindingNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.InvalidLetBindingNameError+invalidLetBindingNameErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameErrorWithName :: Typed.TypedTerm ErrorCore.InvalidLetBindingNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidLetBindingNameError+invalidLetBindingNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the typeMismatch variant of hydra.error.core.InvalidLiteralError+invalidLiteralErrorTypeMismatch :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm ErrorCore.InvalidLiteralError+invalidLiteralErrorTypeMismatch x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidLiteralError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeMismatch"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the constantCondition variant of hydra.error.core.InvalidTermError+invalidTermErrorConstantCondition :: Typed.TypedTerm ErrorCore.ConstantConditionError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorConstantCondition x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "constantCondition"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateBinding variant of hydra.error.core.InvalidTermError+invalidTermErrorDuplicateBinding :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorDuplicateBinding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateBinding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateField variant of hydra.error.core.InvalidTermError+invalidTermErrorDuplicateField :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorDuplicateField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyCaseStatement variant of hydra.error.core.InvalidTermError+invalidTermErrorEmptyCaseStatement :: Typed.TypedTerm ErrorCore.EmptyCaseStatementError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorEmptyCaseStatement x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyCaseStatement"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyLetBindings variant of hydra.error.core.InvalidTermError+invalidTermErrorEmptyLetBindings :: Typed.TypedTerm ErrorCore.EmptyLetBindingsError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorEmptyLetBindings x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyLetBindings"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyTermAnnotation variant of hydra.error.core.InvalidTermError+invalidTermErrorEmptyTermAnnotation :: Typed.TypedTerm ErrorCore.EmptyTermAnnotationError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorEmptyTermAnnotation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyTermAnnotation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyTypeNameInTerm variant of hydra.error.core.InvalidTermError+invalidTermErrorEmptyTypeNameInTerm :: Typed.TypedTerm ErrorCore.EmptyTypeNameInTermError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorEmptyTypeNameInTerm x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyTypeNameInTerm"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidLambdaParameterName variant of hydra.error.core.InvalidTermError+invalidTermErrorInvalidLambdaParameterName :: Typed.TypedTerm ErrorCore.InvalidLambdaParameterNameError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorInvalidLambdaParameterName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidLambdaParameterName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidLetBindingName variant of hydra.error.core.InvalidTermError+invalidTermErrorInvalidLetBindingName :: Typed.TypedTerm ErrorCore.InvalidLetBindingNameError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorInvalidLetBindingName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidLetBindingName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidTypeLambdaParameterName variant of hydra.error.core.InvalidTermError+invalidTermErrorInvalidTypeLambdaParameterName :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorInvalidTypeLambdaParameterName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the nestedTermAnnotation variant of hydra.error.core.InvalidTermError+invalidTermErrorNestedTermAnnotation :: Typed.TypedTerm ErrorCore.NestedTermAnnotationError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorNestedTermAnnotation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nestedTermAnnotation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the redundantWrapUnwrap variant of hydra.error.core.InvalidTermError+invalidTermErrorRedundantWrapUnwrap :: Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorRedundantWrapUnwrap x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "redundantWrapUnwrap"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the selfApplication variant of hydra.error.core.InvalidTermError+invalidTermErrorSelfApplication :: Typed.TypedTerm ErrorCore.SelfApplicationError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorSelfApplication x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "selfApplication"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the termVariableShadowing variant of hydra.error.core.InvalidTermError+invalidTermErrorTermVariableShadowing :: Typed.TypedTerm ErrorCore.TermVariableShadowingError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorTermVariableShadowing x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "termVariableShadowing"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the typeVariableShadowingInTypeLambda variant of hydra.error.core.InvalidTermError+invalidTermErrorTypeVariableShadowingInTypeLambda :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorTypeVariableShadowingInTypeLambda x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeVariableShadowingInTypeLambda"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedTermVariable variant of hydra.error.core.InvalidTermError+invalidTermErrorUndefinedTermVariable :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUndefinedTermVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedTermVariable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedTypeVariableInBindingType variant of hydra.error.core.InvalidTermError+invalidTermErrorUndefinedTypeVariableInBindingType :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUndefinedTypeVariableInBindingType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedTypeVariableInBindingType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedTypeVariableInLambdaDomain variant of hydra.error.core.InvalidTermError+invalidTermErrorUndefinedTypeVariableInLambdaDomain :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUndefinedTypeVariableInLambdaDomain x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedTypeVariableInLambdaDomain"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedTypeVariableInTypeApplication variant of hydra.error.core.InvalidTermError+invalidTermErrorUndefinedTypeVariableInTypeApplication :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUndefinedTypeVariableInTypeApplication x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unknownPrimitiveName variant of hydra.error.core.InvalidTermError+invalidTermErrorUnknownPrimitiveName :: Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUnknownPrimitiveName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unknownPrimitiveName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unnecessaryIdentityApplication variant of hydra.error.core.InvalidTermError+invalidTermErrorUnnecessaryIdentityApplication :: Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUnnecessaryIdentityApplication x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unnecessaryIdentityApplication"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the untypedTermVariable variant of hydra.error.core.InvalidTermError+invalidTermErrorUntypedTermVariable :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm ErrorCore.InvalidTermError+invalidTermErrorUntypedTermVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "untypedTermVariable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateRecordTypeFieldNames variant of hydra.error.core.InvalidTypeError+invalidTypeErrorDuplicateRecordTypeFieldNames :: Typed.TypedTerm ErrorCore.DuplicateRecordTypeFieldNamesError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorDuplicateRecordTypeFieldNames x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateRecordTypeFieldNames"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateUnionTypeFieldNames variant of hydra.error.core.InvalidTypeError+invalidTypeErrorDuplicateUnionTypeFieldNames :: Typed.TypedTerm ErrorCore.DuplicateUnionTypeFieldNamesError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorDuplicateUnionTypeFieldNames x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateUnionTypeFieldNames"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyRecordType variant of hydra.error.core.InvalidTypeError+invalidTypeErrorEmptyRecordType :: Typed.TypedTerm ErrorCore.EmptyRecordTypeError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorEmptyRecordType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyRecordType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyTypeAnnotation variant of hydra.error.core.InvalidTypeError+invalidTypeErrorEmptyTypeAnnotation :: Typed.TypedTerm ErrorCore.EmptyTypeAnnotationError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorEmptyTypeAnnotation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyTypeAnnotation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyUnionType variant of hydra.error.core.InvalidTypeError+invalidTypeErrorEmptyUnionType :: Typed.TypedTerm ErrorCore.EmptyUnionTypeError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorEmptyUnionType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyUnionType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidForallParameterName variant of hydra.error.core.InvalidTypeError+invalidTypeErrorInvalidForallParameterName :: Typed.TypedTerm ErrorCore.InvalidForallParameterNameError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorInvalidForallParameterName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidForallParameterName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidTypeSchemeVariableName variant of hydra.error.core.InvalidTypeError+invalidTypeErrorInvalidTypeSchemeVariableName :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorInvalidTypeSchemeVariableName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidTypeSchemeVariableName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the nestedTypeAnnotation variant of hydra.error.core.InvalidTypeError+invalidTypeErrorNestedTypeAnnotation :: Typed.TypedTerm ErrorCore.NestedTypeAnnotationError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorNestedTypeAnnotation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nestedTypeAnnotation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the nonComparableMapKeyType variant of hydra.error.core.InvalidTypeError+invalidTypeErrorNonComparableMapKeyType :: Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorNonComparableMapKeyType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nonComparableMapKeyType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the nonComparableSetElementType variant of hydra.error.core.InvalidTypeError+invalidTypeErrorNonComparableSetElementType :: Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorNonComparableSetElementType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "nonComparableSetElementType"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the singleVariantUnion variant of hydra.error.core.InvalidTypeError+invalidTypeErrorSingleVariantUnion :: Typed.TypedTerm ErrorCore.SingleVariantUnionError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorSingleVariantUnion x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "singleVariantUnion"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the typeVariableShadowingInForall variant of hydra.error.core.InvalidTypeError+invalidTypeErrorTypeVariableShadowingInForall :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorTypeVariableShadowingInForall x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeVariableShadowingInForall"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedTypeVariable variant of hydra.error.core.InvalidTypeError+invalidTypeErrorUndefinedTypeVariable :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorUndefinedTypeVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedTypeVariable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the voidInNonBottomPosition variant of hydra.error.core.InvalidTypeError+invalidTypeErrorVoidInNonBottomPosition :: Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError -> Typed.TypedTerm ErrorCore.InvalidTypeError+invalidTypeErrorVoidInNonBottomPosition x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "voidInNonBottomPosition"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.error.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath+invalidTypeLambdaParameterNameErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorName :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm Core.Name+invalidTypeLambdaParameterNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorWithLocation :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorWithName :: Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorLocation :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm Paths.SubtermPath+invalidTypeSchemeVariableNameErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorName :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm Core.Name+invalidTypeSchemeVariableNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorWithLocation :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorWithName :: Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchError :: Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm ErrorCore.LiteralTypeMismatchError+literalTypeMismatchError expectedType actualType =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (Typed.unTypedTerm expectedType)},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Typed.unTypedTerm actualType)}]}))+-- | DSL accessor for the actualType field of hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchErrorActualType :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm Core.LiteralType+literalTypeMismatchErrorActualType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+        Core.projectionFieldName = (Core.Name "actualType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the expectedType field of hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchErrorExpectedType :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm Core.LiteralType+literalTypeMismatchErrorExpectedType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+        Core.projectionFieldName = (Core.Name "expectedType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the actualType field of hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchErrorWithActualType :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm ErrorCore.LiteralTypeMismatchError+literalTypeMismatchErrorWithActualType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+              Core.projectionFieldName = (Core.Name "expectedType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the expectedType field of hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchErrorWithExpectedType :: Typed.TypedTerm ErrorCore.LiteralTypeMismatchError -> Typed.TypedTerm Core.LiteralType -> Typed.TypedTerm ErrorCore.LiteralTypeMismatchError+literalTypeMismatchErrorWithExpectedType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+              Core.projectionFieldName = (Core.Name "actualType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.core.NestedTermAnnotationError+nestedTermAnnotationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTermAnnotationError+nestedTermAnnotationError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.NestedTermAnnotationError+nestedTermAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.NestedTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath+nestedTermAnnotationErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.NestedTermAnnotationError+nestedTermAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.NestedTermAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTermAnnotationError+nestedTermAnnotationErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.NestedTypeAnnotationError+nestedTypeAnnotationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTypeAnnotationError+nestedTypeAnnotationError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.NestedTypeAnnotationError+nestedTypeAnnotationErrorLocation :: Typed.TypedTerm ErrorCore.NestedTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath+nestedTypeAnnotationErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.NestedTypeAnnotationError+nestedTypeAnnotationErrorWithLocation :: Typed.TypedTerm ErrorCore.NestedTypeAnnotationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NestedTypeAnnotationError+nestedTypeAnnotationErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError+nonComparableMapKeyTypeError location keyType =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "keyType"),+          Core.fieldTerm = (Typed.unTypedTerm keyType)}]}))+-- | DSL accessor for the keyType field of hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorKeyType :: Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError -> Typed.TypedTerm Core.Type+nonComparableMapKeyTypeErrorKeyType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+        Core.projectionFieldName = (Core.Name "keyType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the location field of hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorLocation :: Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError -> Typed.TypedTerm Paths.SubtermPath+nonComparableMapKeyTypeErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the keyType field of hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorWithKeyType :: Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorWithKeyType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keyType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the location field of hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorWithLocation :: Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NonComparableMapKeyTypeError+nonComparableMapKeyTypeErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "keyType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+              Core.projectionFieldName = (Core.Name "keyType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError+nonComparableSetElementTypeError location elementType =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "elementType"),+          Core.fieldTerm = (Typed.unTypedTerm elementType)}]}))+-- | DSL accessor for the elementType field of hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorElementType :: Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError -> Typed.TypedTerm Core.Type+nonComparableSetElementTypeErrorElementType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+        Core.projectionFieldName = (Core.Name "elementType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the location field of hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorLocation :: Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError -> Typed.TypedTerm Paths.SubtermPath+nonComparableSetElementTypeErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the elementType field of hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorWithElementType :: Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorWithElementType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "elementType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the location field of hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorWithLocation :: Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.NonComparableSetElementTypeError+nonComparableSetElementTypeErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "elementType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+              Core.projectionFieldName = (Core.Name "elementType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError+redundantWrapUnwrapError location typeName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)}]}))+-- | DSL accessor for the location field of hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapErrorLocation :: Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError -> Typed.TypedTerm Paths.SubtermPath+redundantWrapUnwrapErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapErrorTypeName :: Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError -> Typed.TypedTerm Core.Name+redundantWrapUnwrapErrorTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapErrorWithLocation :: Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError+redundantWrapUnwrapErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeName field of hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapErrorWithTypeName :: Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.RedundantWrapUnwrapError+redundantWrapUnwrapErrorWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.SelfApplicationError+selfApplicationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.SelfApplicationError+selfApplicationError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.SelfApplicationError+selfApplicationErrorLocation :: Typed.TypedTerm ErrorCore.SelfApplicationError -> Typed.TypedTerm Paths.SubtermPath+selfApplicationErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.SelfApplicationError+selfApplicationErrorName :: Typed.TypedTerm ErrorCore.SelfApplicationError -> Typed.TypedTerm Core.Name+selfApplicationErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.SelfApplicationError+selfApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.SelfApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.SelfApplicationError+selfApplicationErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.SelfApplicationError+selfApplicationErrorWithName :: Typed.TypedTerm ErrorCore.SelfApplicationError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.SelfApplicationError+selfApplicationErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.SingleVariantUnionError+singleVariantUnionError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.SingleVariantUnionError+singleVariantUnionError location fieldName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm fieldName)}]}))+-- | DSL accessor for the fieldName field of hydra.error.core.SingleVariantUnionError+singleVariantUnionErrorFieldName :: Typed.TypedTerm ErrorCore.SingleVariantUnionError -> Typed.TypedTerm Core.Name+singleVariantUnionErrorFieldName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+        Core.projectionFieldName = (Core.Name "fieldName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the location field of hydra.error.core.SingleVariantUnionError+singleVariantUnionErrorLocation :: Typed.TypedTerm ErrorCore.SingleVariantUnionError -> Typed.TypedTerm Paths.SubtermPath+singleVariantUnionErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the fieldName field of hydra.error.core.SingleVariantUnionError+singleVariantUnionErrorWithFieldName :: Typed.TypedTerm ErrorCore.SingleVariantUnionError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.SingleVariantUnionError+singleVariantUnionErrorWithFieldName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the location field of hydra.error.core.SingleVariantUnionError+singleVariantUnionErrorWithLocation :: Typed.TypedTerm ErrorCore.SingleVariantUnionError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.SingleVariantUnionError+singleVariantUnionErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+              Core.projectionFieldName = (Core.Name "fieldName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.core.TermVariableShadowingError+termVariableShadowingError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.TermVariableShadowingError+termVariableShadowingError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.TermVariableShadowingError+termVariableShadowingErrorLocation :: Typed.TypedTerm ErrorCore.TermVariableShadowingError -> Typed.TypedTerm Paths.SubtermPath+termVariableShadowingErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.TermVariableShadowingError+termVariableShadowingErrorName :: Typed.TypedTerm ErrorCore.TermVariableShadowingError -> Typed.TypedTerm Core.Name+termVariableShadowingErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.TermVariableShadowingError+termVariableShadowingErrorWithLocation :: Typed.TypedTerm ErrorCore.TermVariableShadowingError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TermVariableShadowingError+termVariableShadowingErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.TermVariableShadowingError+termVariableShadowingErrorWithName :: Typed.TypedTerm ErrorCore.TermVariableShadowingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.TermVariableShadowingError+termVariableShadowingErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError+typeVariableShadowingInForallError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError -> Typed.TypedTerm Paths.SubtermPath+typeVariableShadowingInForallErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorName :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError -> Typed.TypedTerm Core.Name+typeVariableShadowingInForallErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorWithLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorWithName :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInForallError+typeVariableShadowingInForallErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError -> Typed.TypedTerm Paths.SubtermPath+typeVariableShadowingInTypeLambdaErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorName :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError -> Typed.TypedTerm Core.Name+typeVariableShadowingInTypeLambdaErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorWithLocation :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorWithName :: Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UndefinedFieldError+undefinedFieldError :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedFieldError+undefinedFieldError fieldName typeName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm fieldName)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)}]}))+-- | DSL accessor for the fieldName field of hydra.error.core.UndefinedFieldError+undefinedFieldErrorFieldName :: Typed.TypedTerm ErrorCore.UndefinedFieldError -> Typed.TypedTerm Core.Name+undefinedFieldErrorFieldName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+        Core.projectionFieldName = (Core.Name "fieldName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.error.core.UndefinedFieldError+undefinedFieldErrorTypeName :: Typed.TypedTerm ErrorCore.UndefinedFieldError -> Typed.TypedTerm Core.Name+undefinedFieldErrorTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the fieldName field of hydra.error.core.UndefinedFieldError+undefinedFieldErrorWithFieldName :: Typed.TypedTerm ErrorCore.UndefinedFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedFieldError+undefinedFieldErrorWithFieldName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeName field of hydra.error.core.UndefinedFieldError+undefinedFieldErrorWithTypeName :: Typed.TypedTerm ErrorCore.UndefinedFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedFieldError+undefinedFieldErrorWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+              Core.projectionFieldName = (Core.Name "fieldName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UndefinedTermVariableError+undefinedTermVariableError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTermVariableError+undefinedTermVariableError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.UndefinedTermVariableError+undefinedTermVariableErrorLocation :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm Paths.SubtermPath+undefinedTermVariableErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.UndefinedTermVariableError+undefinedTermVariableErrorName :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm Core.Name+undefinedTermVariableErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UndefinedTermVariableError+undefinedTermVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTermVariableError+undefinedTermVariableErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.UndefinedTermVariableError+undefinedTermVariableErrorWithName :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTermVariableError+undefinedTermVariableErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableError+undefinedTypeVariableError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableErrorLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableError -> Typed.TypedTerm Paths.SubtermPath+undefinedTypeVariableErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableErrorName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableError -> Typed.TypedTerm Core.Name+undefinedTypeVariableErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableError+undefinedTypeVariableErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableErrorWithName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableError+undefinedTypeVariableErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError -> Typed.TypedTerm Paths.SubtermPath+undefinedTypeVariableInBindingTypeErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError -> Typed.TypedTerm Core.Name+undefinedTypeVariableInBindingTypeErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorWithName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Typed.TypedTerm Paths.SubtermPath+undefinedTypeVariableInLambdaDomainErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Typed.TypedTerm Core.Name+undefinedTypeVariableInLambdaDomainErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorWithName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Typed.TypedTerm Paths.SubtermPath+undefinedTypeVariableInTypeApplicationErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Typed.TypedTerm Core.Name+undefinedTypeVariableInTypeApplicationErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorWithName :: Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantError :: Typed.TypedTerm Variants.TermVariant -> Typed.TypedTerm Core.Term -> Typed.TypedTerm ErrorCore.UnexpectedTermVariantError+unexpectedTermVariantError expectedVariant actualTerm =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Typed.unTypedTerm expectedVariant)},+        Core.Field {+          Core.fieldName = (Core.Name "actualTerm"),+          Core.fieldTerm = (Typed.unTypedTerm actualTerm)}]}))+-- | DSL accessor for the actualTerm field of hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantErrorActualTerm :: Typed.TypedTerm ErrorCore.UnexpectedTermVariantError -> Typed.TypedTerm Core.Term+unexpectedTermVariantErrorActualTerm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+        Core.projectionFieldName = (Core.Name "actualTerm")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the expectedVariant field of hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantErrorExpectedVariant :: Typed.TypedTerm ErrorCore.UnexpectedTermVariantError -> Typed.TypedTerm Variants.TermVariant+unexpectedTermVariantErrorExpectedVariant x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+        Core.projectionFieldName = (Core.Name "expectedVariant")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the actualTerm field of hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantErrorWithActualTerm :: Typed.TypedTerm ErrorCore.UnexpectedTermVariantError -> Typed.TypedTerm Core.Term -> Typed.TypedTerm ErrorCore.UnexpectedTermVariantError+unexpectedTermVariantErrorWithActualTerm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+              Core.projectionFieldName = (Core.Name "expectedVariant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actualTerm"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the expectedVariant field of hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantErrorWithExpectedVariant :: Typed.TypedTerm ErrorCore.UnexpectedTermVariantError -> Typed.TypedTerm Variants.TermVariant -> Typed.TypedTerm ErrorCore.UnexpectedTermVariantError+unexpectedTermVariantErrorWithExpectedVariant original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "actualTerm"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+              Core.projectionFieldName = (Core.Name "actualTerm")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantError :: Typed.TypedTerm Variants.TypeVariant -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError+unexpectedTypeVariantError expectedVariant actualType =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Typed.unTypedTerm expectedVariant)},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Typed.unTypedTerm actualType)}]}))+-- | DSL accessor for the actualType field of hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantErrorActualType :: Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError -> Typed.TypedTerm Core.Type+unexpectedTypeVariantErrorActualType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+        Core.projectionFieldName = (Core.Name "actualType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the expectedVariant field of hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantErrorExpectedVariant :: Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError -> Typed.TypedTerm Variants.TypeVariant+unexpectedTypeVariantErrorExpectedVariant x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+        Core.projectionFieldName = (Core.Name "expectedVariant")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the actualType field of hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantErrorWithActualType :: Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError+unexpectedTypeVariantErrorWithActualType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+              Core.projectionFieldName = (Core.Name "expectedVariant")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the expectedVariant field of hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantErrorWithExpectedVariant :: Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError -> Typed.TypedTerm Variants.TypeVariant -> Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError+unexpectedTypeVariantErrorWithExpectedVariant original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+              Core.projectionFieldName = (Core.Name "actualType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError+unknownPrimitiveNameError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameErrorLocation :: Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError -> Typed.TypedTerm Paths.SubtermPath+unknownPrimitiveNameErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameErrorName :: Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError -> Typed.TypedTerm Core.Name+unknownPrimitiveNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameErrorWithLocation :: Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError+unknownPrimitiveNameErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameErrorWithName :: Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UnknownPrimitiveNameError+unknownPrimitiveNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationErrorLocation :: Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError -> Typed.TypedTerm Paths.SubtermPath+unnecessaryIdentityApplicationErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationErrorWithLocation :: Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.UntypedTermVariableError+untypedTermVariableError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UntypedTermVariableError+untypedTermVariableError location name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the location field of hydra.error.core.UntypedTermVariableError+untypedTermVariableErrorLocation :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm Paths.SubtermPath+untypedTermVariableErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.core.UntypedTermVariableError+untypedTermVariableErrorName :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm Core.Name+untypedTermVariableErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.UntypedTermVariableError+untypedTermVariableErrorWithLocation :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.UntypedTermVariableError+untypedTermVariableErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.core.UntypedTermVariableError+untypedTermVariableErrorWithName :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorCore.UntypedTermVariableError+untypedTermVariableErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+              Core.projectionFieldName = (Core.Name "location")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.core.VoidInNonBottomPositionError+voidInNonBottomPositionError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError+voidInNonBottomPositionError location =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm location)}]}))+-- | DSL accessor for the location field of hydra.error.core.VoidInNonBottomPositionError+voidInNonBottomPositionErrorLocation :: Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError -> Typed.TypedTerm Paths.SubtermPath+voidInNonBottomPositionErrorLocation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"),+        Core.projectionFieldName = (Core.Name "location")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the location field of hydra.error.core.VoidInNonBottomPositionError+voidInNonBottomPositionErrorWithLocation :: Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm ErrorCore.VoidInNonBottomPositionError+voidInNonBottomPositionErrorWithLocation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+ src/main/haskell/Hydra/Dsl/Error/Packaging.hs view
@@ -0,0 +1,806 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.error.packaging++module Hydra.Dsl.Error.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Util as DslUtil+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typed as Typed+import qualified Hydra.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL constructor for hydra.error.packaging.ConflictingModuleNameError+conflictingModuleNameError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError+conflictingModuleNameError first second =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "first"),+          Core.fieldTerm = (Typed.unTypedTerm first)},+        Core.Field {+          Core.fieldName = (Core.Name "second"),+          Core.fieldTerm = (Typed.unTypedTerm second)}]}))+-- | DSL accessor for the first field of hydra.error.packaging.ConflictingModuleNameError+conflictingModuleNameErrorFirst :: Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError -> Typed.TypedTerm Packaging.ModuleName+conflictingModuleNameErrorFirst x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+        Core.projectionFieldName = (Core.Name "first")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the second field of hydra.error.packaging.ConflictingModuleNameError+conflictingModuleNameErrorSecond :: Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError -> Typed.TypedTerm Packaging.ModuleName+conflictingModuleNameErrorSecond x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+        Core.projectionFieldName = (Core.Name "second")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the first field of hydra.error.packaging.ConflictingModuleNameError+conflictingModuleNameErrorWithFirst :: Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError+conflictingModuleNameErrorWithFirst original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "first"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "second"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+              Core.projectionFieldName = (Core.Name "second")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the second field of hydra.error.packaging.ConflictingModuleNameError+conflictingModuleNameErrorWithSecond :: Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError+conflictingModuleNameErrorWithSecond original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "first"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+              Core.projectionFieldName = (Core.Name "first")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "second"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError+conflictingVariantNameError moduleName typeName variantName conflictingName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm typeName)},+        Core.Field {+          Core.fieldName = (Core.Name "variantName"),+          Core.fieldTerm = (Typed.unTypedTerm variantName)},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingName"),+          Core.fieldTerm = (Typed.unTypedTerm conflictingName)}]}))+-- | DSL accessor for the conflictingName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorConflictingName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Core.Name+conflictingVariantNameErrorConflictingName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+        Core.projectionFieldName = (Core.Name "conflictingName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Packaging.ModuleName+conflictingVariantNameErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorTypeName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Core.Name+conflictingVariantNameErrorTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+        Core.projectionFieldName = (Core.Name "typeName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the variantName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorVariantName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Core.Name+conflictingVariantNameErrorVariantName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+        Core.projectionFieldName = (Core.Name "variantName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the conflictingName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorWithConflictingName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError+conflictingVariantNameErrorWithConflictingName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "variantName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "variantName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the moduleName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError+conflictingVariantNameErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "variantName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "variantName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "conflictingName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorWithTypeName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError+conflictingVariantNameErrorWithTypeName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "variantName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "variantName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "conflictingName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the variantName field of hydra.error.packaging.ConflictingVariantNameError+conflictingVariantNameErrorWithVariantName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError+conflictingVariantNameErrorWithVariantName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "typeName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "variantName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "conflictingName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+              Core.projectionFieldName = (Core.Name "conflictingName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.packaging.DefinitionNotInModuleNameError+definitionNotInModuleNameError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError+definitionNotInModuleNameError moduleName name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError -> Typed.TypedTerm Packaging.ModuleName+definitionNotInModuleNameErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.packaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorName :: Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError -> Typed.TypedTerm Core.Name+definitionNotInModuleNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the moduleName field of hydra.error.packaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.packaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorWithName :: Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError+definitionNotInModuleNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError+definitionsOutOfOrderError moduleName precedingName followingName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "precedingName"),+          Core.fieldTerm = (Typed.unTypedTerm precedingName)},+        Core.Field {+          Core.fieldName = (Core.Name "followingName"),+          Core.fieldTerm = (Typed.unTypedTerm followingName)}]}))+-- | DSL accessor for the followingName field of hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorFollowingName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Core.Name+definitionsOutOfOrderErrorFollowingName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+        Core.projectionFieldName = (Core.Name "followingName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorModuleName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Packaging.ModuleName+definitionsOutOfOrderErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the precedingName field of hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorPrecedingName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Core.Name+definitionsOutOfOrderErrorPrecedingName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+        Core.projectionFieldName = (Core.Name "precedingName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the followingName field of hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorWithFollowingName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorWithFollowingName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "precedingName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+              Core.projectionFieldName = (Core.Name "precedingName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "followingName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the moduleName field of hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "precedingName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+              Core.projectionFieldName = (Core.Name "precedingName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "followingName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+              Core.projectionFieldName = (Core.Name "followingName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the precedingName field of hydra.error.packaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorWithPrecedingName :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError+definitionsOutOfOrderErrorWithPrecedingName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "precedingName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "followingName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+              Core.projectionFieldName = (Core.Name "followingName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.error.packaging.DuplicateDefinitionNameError+duplicateDefinitionNameError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError+duplicateDefinitionNameError moduleName name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName+duplicateDefinitionNameErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.packaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorName :: Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError -> Typed.TypedTerm Core.Name+duplicateDefinitionNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the moduleName field of hydra.error.packaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.packaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorWithName :: Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError+duplicateDefinitionNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.packaging.DuplicateModuleNameError+duplicateModuleNameError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.DuplicateModuleNameError+duplicateModuleNameError moduleName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)}]}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.DuplicateModuleNameError+duplicateModuleNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateModuleNameError -> Typed.TypedTerm Packaging.ModuleName+duplicateModuleNameErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the moduleName field of hydra.error.packaging.DuplicateModuleNameError+duplicateModuleNameErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateModuleNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.DuplicateModuleNameError+duplicateModuleNameErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError+invalidDefinitionNameError moduleName name expectedConvention =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "expectedConvention"),+          Core.fieldTerm = (Typed.unTypedTerm expectedConvention)}]}))+-- | DSL accessor for the expectedConvention field of hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameErrorExpectedConvention :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Util.CaseConvention+invalidDefinitionNameErrorExpectedConvention x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+        Core.projectionFieldName = (Core.Name "expectedConvention")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameErrorModuleName :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName+invalidDefinitionNameErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameErrorName :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Core.Name+invalidDefinitionNameErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the expectedConvention field of hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameErrorWithExpectedConvention :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Util.CaseConvention -> Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError+invalidDefinitionNameErrorWithExpectedConvention original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expectedConvention"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the moduleName field of hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError+invalidDefinitionNameErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expectedConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "expectedConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.packaging.InvalidDefinitionNameError+invalidDefinitionNameErrorWithName :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError+invalidDefinitionNameErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expectedConvention"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+              Core.projectionFieldName = (Core.Name "expectedConvention")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the conflictingVariantName variant of hydra.error.packaging.InvalidModuleError+invalidModuleErrorConflictingVariantName :: Typed.TypedTerm ErrorPackaging.ConflictingVariantNameError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError+invalidModuleErrorConflictingVariantName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "conflictingVariantName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the definitionNotInModuleName variant of hydra.error.packaging.InvalidModuleError+invalidModuleErrorDefinitionNotInModuleName :: Typed.TypedTerm ErrorPackaging.DefinitionNotInModuleNameError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError+invalidModuleErrorDefinitionNotInModuleName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "definitionNotInModuleName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the definitionsOutOfOrder variant of hydra.error.packaging.InvalidModuleError+invalidModuleErrorDefinitionsOutOfOrder :: Typed.TypedTerm ErrorPackaging.DefinitionsOutOfOrderError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError+invalidModuleErrorDefinitionsOutOfOrder x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "definitionsOutOfOrder"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateDefinitionName variant of hydra.error.packaging.InvalidModuleError+invalidModuleErrorDuplicateDefinitionName :: Typed.TypedTerm ErrorPackaging.DuplicateDefinitionNameError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError+invalidModuleErrorDuplicateDefinitionName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateDefinitionName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidDefinitionName variant of hydra.error.packaging.InvalidModuleError+invalidModuleErrorInvalidDefinitionName :: Typed.TypedTerm ErrorPackaging.InvalidDefinitionNameError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError+invalidModuleErrorInvalidDefinitionName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidDefinitionName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidModuleNameConvention variant of hydra.error.packaging.InvalidModuleError+invalidModuleErrorInvalidModuleNameConvention :: Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError+invalidModuleErrorInvalidModuleNameConvention x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidModuleNameConvention"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the missingDocumentation variant of hydra.error.packaging.InvalidModuleError+invalidModuleErrorMissingDocumentation :: Typed.TypedTerm ErrorPackaging.MissingDocumentationError -> Typed.TypedTerm ErrorPackaging.InvalidModuleError+invalidModuleErrorMissingDocumentation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "missingDocumentation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.error.packaging.InvalidModuleNameConventionError+invalidModuleNameConventionError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError+invalidModuleNameConventionError moduleName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)}]}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.InvalidModuleNameConventionError+invalidModuleNameConventionErrorModuleName :: Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError -> Typed.TypedTerm Packaging.ModuleName+invalidModuleNameConventionErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the moduleName field of hydra.error.packaging.InvalidModuleNameConventionError+invalidModuleNameConventionErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.InvalidModuleNameConventionError+invalidModuleNameConventionErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the conflictingModuleName variant of hydra.error.packaging.InvalidPackageError+invalidPackageErrorConflictingModuleName :: Typed.TypedTerm ErrorPackaging.ConflictingModuleNameError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError+invalidPackageErrorConflictingModuleName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "conflictingModuleName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateModuleName variant of hydra.error.packaging.InvalidPackageError+invalidPackageErrorDuplicateModuleName :: Typed.TypedTerm ErrorPackaging.DuplicateModuleNameError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError+invalidPackageErrorDuplicateModuleName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateModuleName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidModule variant of hydra.error.packaging.InvalidPackageError+invalidPackageErrorInvalidModule :: Typed.TypedTerm ErrorPackaging.InvalidModuleError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError+invalidPackageErrorInvalidModule x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidModule"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidPackageName variant of hydra.error.packaging.InvalidPackageError+invalidPackageErrorInvalidPackageName :: Typed.TypedTerm ErrorPackaging.InvalidPackageNameError -> Typed.TypedTerm ErrorPackaging.InvalidPackageError+invalidPackageErrorInvalidPackageName x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidPackageName"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.error.packaging.InvalidPackageNameError+invalidPackageNameError :: Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm ErrorPackaging.InvalidPackageNameError+invalidPackageNameError packageName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageName"),+          Core.fieldTerm = (Typed.unTypedTerm packageName)}]}))+-- | DSL accessor for the packageName field of hydra.error.packaging.InvalidPackageNameError+invalidPackageNameErrorPackageName :: Typed.TypedTerm ErrorPackaging.InvalidPackageNameError -> Typed.TypedTerm Packaging.PackageName+invalidPackageNameErrorPackageName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"),+        Core.projectionFieldName = (Core.Name "packageName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the packageName field of hydra.error.packaging.InvalidPackageNameError+invalidPackageNameErrorWithPackageName :: Typed.TypedTerm ErrorPackaging.InvalidPackageNameError -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm ErrorPackaging.InvalidPackageNameError+invalidPackageNameErrorWithPackageName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "packageName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.error.packaging.MissingDocumentationError+missingDocumentationError :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.MissingDocumentationError+missingDocumentationError moduleName name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the moduleName field of hydra.error.packaging.MissingDocumentationError+missingDocumentationErrorModuleName :: Typed.TypedTerm ErrorPackaging.MissingDocumentationError -> Typed.TypedTerm Packaging.ModuleName+missingDocumentationErrorModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.error.packaging.MissingDocumentationError+missingDocumentationErrorName :: Typed.TypedTerm ErrorPackaging.MissingDocumentationError -> Typed.TypedTerm Core.Name+missingDocumentationErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the moduleName field of hydra.error.packaging.MissingDocumentationError+missingDocumentationErrorWithModuleName :: Typed.TypedTerm ErrorPackaging.MissingDocumentationError -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm ErrorPackaging.MissingDocumentationError+missingDocumentationErrorWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.error.packaging.MissingDocumentationError+missingDocumentationErrorWithName :: Typed.TypedTerm ErrorPackaging.MissingDocumentationError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm ErrorPackaging.MissingDocumentationError+missingDocumentationErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+ src/main/haskell/Hydra/Dsl/Errors.hs view
@@ -0,0 +1,714 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.errors++module Hydra.Dsl.Errors where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Error.Checking as ErrorChecking+import qualified Hydra.Dsl.Error.Core as DslErrorCore+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Dsl.Variants as DslVariants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Errors as Errors+import qualified Hydra.Paths as Paths+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL constructor for the hydra.errors.DecodingError wrapper+decodingError :: Typed.TypedTerm String -> Typed.TypedTerm Errors.DecodingError+decodingError x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the checking variant of hydra.errors.Error+errorChecking :: Typed.TypedTerm Checking.CheckingError -> Typed.TypedTerm Errors.Error+errorChecking x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "checking"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the decoding variant of hydra.errors.Error+errorDecoding :: Typed.TypedTerm Errors.DecodingError -> Typed.TypedTerm Errors.Error+errorDecoding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "decoding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateBinding variant of hydra.errors.Error+errorDuplicateBinding :: Typed.TypedTerm ErrorCore.DuplicateBindingError -> Typed.TypedTerm Errors.Error+errorDuplicateBinding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateBinding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the duplicateField variant of hydra.errors.Error+errorDuplicateField :: Typed.TypedTerm ErrorCore.DuplicateFieldError -> Typed.TypedTerm Errors.Error+errorDuplicateField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "duplicateField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the extraction variant of hydra.errors.Error+errorExtraction :: Typed.TypedTerm Errors.ExtractionError -> Typed.TypedTerm Errors.Error+errorExtraction x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "extraction"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the inference variant of hydra.errors.Error+errorInference :: Typed.TypedTerm Errors.InferenceError -> Typed.TypedTerm Errors.Error+errorInference x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "inference"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the invalidLiteral variant of hydra.errors.Error+errorInvalidLiteral :: Typed.TypedTerm ErrorCore.InvalidLiteralError -> Typed.TypedTerm Errors.Error+errorInvalidLiteral x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "invalidLiteral"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the other variant of hydra.errors.Error+errorOther :: Typed.TypedTerm Errors.OtherError -> Typed.TypedTerm Errors.Error+errorOther x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "other"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the resolution variant of hydra.errors.Error+errorResolution :: Typed.TypedTerm Errors.ResolutionError -> Typed.TypedTerm Errors.Error+errorResolution x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "resolution"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedField variant of hydra.errors.Error+errorUndefinedField :: Typed.TypedTerm ErrorCore.UndefinedFieldError -> Typed.TypedTerm Errors.Error+errorUndefinedField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the undefinedTermVariable variant of hydra.errors.Error+errorUndefinedTermVariable :: Typed.TypedTerm ErrorCore.UndefinedTermVariableError -> Typed.TypedTerm Errors.Error+errorUndefinedTermVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "undefinedTermVariable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unexpectedTermVariant variant of hydra.errors.Error+errorUnexpectedTermVariant :: Typed.TypedTerm ErrorCore.UnexpectedTermVariantError -> Typed.TypedTerm Errors.Error+errorUnexpectedTermVariant x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unexpectedTermVariant"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unexpectedTypeVariant variant of hydra.errors.Error+errorUnexpectedTypeVariant :: Typed.TypedTerm ErrorCore.UnexpectedTypeVariantError -> Typed.TypedTerm Errors.Error+errorUnexpectedTypeVariant x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unexpectedTypeVariant"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unification variant of hydra.errors.Error+errorUnification :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Errors.Error+errorUnification x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unification"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the untypedTermVariable variant of hydra.errors.Error+errorUntypedTermVariable :: Typed.TypedTerm ErrorCore.UntypedTermVariableError -> Typed.TypedTerm Errors.Error+errorUntypedTermVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "untypedTermVariable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the emptyList variant of hydra.errors.ExtractionError+extractionErrorEmptyList :: Typed.TypedTerm Errors.EmptyListError -> Typed.TypedTerm Errors.ExtractionError+extractionErrorEmptyList x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "emptyList"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the multipleBindings variant of hydra.errors.ExtractionError+extractionErrorMultipleBindings :: Typed.TypedTerm Errors.MultipleBindingsError -> Typed.TypedTerm Errors.ExtractionError+extractionErrorMultipleBindings x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "multipleBindings"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the multipleFields variant of hydra.errors.ExtractionError+extractionErrorMultipleFields :: Typed.TypedTerm Errors.MultipleFieldsError -> Typed.TypedTerm Errors.ExtractionError+extractionErrorMultipleFields x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "multipleFields"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the noMatchingField variant of hydra.errors.ExtractionError+extractionErrorNoMatchingField :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Errors.ExtractionError+extractionErrorNoMatchingField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "noMatchingField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the noSuchBinding variant of hydra.errors.ExtractionError+extractionErrorNoSuchBinding :: Typed.TypedTerm Errors.NoSuchBindingError -> Typed.TypedTerm Errors.ExtractionError+extractionErrorNoSuchBinding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "noSuchBinding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the notEnoughCases variant of hydra.errors.ExtractionError+extractionErrorNotEnoughCases :: Typed.TypedTerm Errors.NotEnoughCasesError -> Typed.TypedTerm Errors.ExtractionError+extractionErrorNotEnoughCases x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "notEnoughCases"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unexpectedShape variant of hydra.errors.ExtractionError+extractionErrorUnexpectedShape :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm Errors.ExtractionError+extractionErrorUnexpectedShape x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unexpectedShape"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the checking variant of hydra.errors.InferenceError+inferenceErrorChecking :: Typed.TypedTerm Checking.CheckingError -> Typed.TypedTerm Errors.InferenceError+inferenceErrorChecking x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "checking"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the other variant of hydra.errors.InferenceError+inferenceErrorOther :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm Errors.InferenceError+inferenceErrorOther x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "other"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unification variant of hydra.errors.InferenceError+inferenceErrorUnification :: Typed.TypedTerm Errors.UnificationInferenceError -> Typed.TypedTerm Errors.InferenceError+inferenceErrorUnification x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unification"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.errors.MultipleBindingsError+multipleBindingsError :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.MultipleBindingsError+multipleBindingsError name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.MultipleBindingsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the name field of hydra.errors.MultipleBindingsError+multipleBindingsErrorName :: Typed.TypedTerm Errors.MultipleBindingsError -> Typed.TypedTerm Core.Name+multipleBindingsErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.MultipleBindingsError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.errors.MultipleBindingsError+multipleBindingsErrorWithName :: Typed.TypedTerm Errors.MultipleBindingsError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.MultipleBindingsError+multipleBindingsErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.MultipleBindingsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.errors.MultipleFieldsError+multipleFieldsError :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.MultipleFieldsError+multipleFieldsError fieldName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.MultipleFieldsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm fieldName)}]}))+-- | DSL accessor for the fieldName field of hydra.errors.MultipleFieldsError+multipleFieldsErrorFieldName :: Typed.TypedTerm Errors.MultipleFieldsError -> Typed.TypedTerm Core.Name+multipleFieldsErrorFieldName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.MultipleFieldsError"),+        Core.projectionFieldName = (Core.Name "fieldName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the fieldName field of hydra.errors.MultipleFieldsError+multipleFieldsErrorWithFieldName :: Typed.TypedTerm Errors.MultipleFieldsError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.MultipleFieldsError+multipleFieldsErrorWithFieldName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.MultipleFieldsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.errors.NoMatchingFieldError+noMatchingFieldError :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoMatchingFieldError+noMatchingFieldError fieldName =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm fieldName)}]}))+-- | DSL accessor for the fieldName field of hydra.errors.NoMatchingFieldError+noMatchingFieldErrorFieldName :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Core.Name+noMatchingFieldErrorFieldName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"),+        Core.projectionFieldName = (Core.Name "fieldName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the fieldName field of hydra.errors.NoMatchingFieldError+noMatchingFieldErrorWithFieldName :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoMatchingFieldError+noMatchingFieldErrorWithFieldName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.errors.NoSuchBindingError+noSuchBindingError :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchBindingError+noSuchBindingError name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoSuchBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the name field of hydra.errors.NoSuchBindingError+noSuchBindingErrorName :: Typed.TypedTerm Errors.NoSuchBindingError -> Typed.TypedTerm Core.Name+noSuchBindingErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.NoSuchBindingError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.errors.NoSuchBindingError+noSuchBindingErrorWithName :: Typed.TypedTerm Errors.NoSuchBindingError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchBindingError+noSuchBindingErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoSuchBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.errors.NoSuchPrimitiveError+noSuchPrimitiveError :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchPrimitiveError+noSuchPrimitiveError name =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)}]}))+-- | DSL accessor for the name field of hydra.errors.NoSuchPrimitiveError+noSuchPrimitiveErrorName :: Typed.TypedTerm Errors.NoSuchPrimitiveError -> Typed.TypedTerm Core.Name+noSuchPrimitiveErrorName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.errors.NoSuchPrimitiveError+noSuchPrimitiveErrorWithName :: Typed.TypedTerm Errors.NoSuchPrimitiveError -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Errors.NoSuchPrimitiveError+noSuchPrimitiveErrorWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for the hydra.errors.OtherError wrapper+otherError :: Typed.TypedTerm String -> Typed.TypedTerm Errors.OtherError+otherError x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.errors.OtherInferenceError+otherInferenceError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm String -> Typed.TypedTerm Errors.OtherInferenceError+otherInferenceError path message =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm message)}]}))+-- | DSL accessor for the message field of hydra.errors.OtherInferenceError+otherInferenceErrorMessage :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm String+otherInferenceErrorMessage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+        Core.projectionFieldName = (Core.Name "message")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the path field of hydra.errors.OtherInferenceError+otherInferenceErrorPath :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm Paths.SubtermPath+otherInferenceErrorPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the message field of hydra.errors.OtherInferenceError+otherInferenceErrorWithMessage :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm String -> Typed.TypedTerm Errors.OtherInferenceError+otherInferenceErrorWithMessage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the path field of hydra.errors.OtherInferenceError+otherInferenceErrorWithPath :: Typed.TypedTerm Errors.OtherInferenceError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Errors.OtherInferenceError+otherInferenceErrorWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.errors.OtherResolutionError wrapper+otherResolutionError :: Typed.TypedTerm String -> Typed.TypedTerm Errors.OtherResolutionError+otherResolutionError x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherResolutionError"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the noMatchingField variant of hydra.errors.ResolutionError+resolutionErrorNoMatchingField :: Typed.TypedTerm Errors.NoMatchingFieldError -> Typed.TypedTerm Errors.ResolutionError+resolutionErrorNoMatchingField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "noMatchingField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the noSuchBinding variant of hydra.errors.ResolutionError+resolutionErrorNoSuchBinding :: Typed.TypedTerm Errors.NoSuchBindingError -> Typed.TypedTerm Errors.ResolutionError+resolutionErrorNoSuchBinding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "noSuchBinding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the noSuchPrimitive variant of hydra.errors.ResolutionError+resolutionErrorNoSuchPrimitive :: Typed.TypedTerm Errors.NoSuchPrimitiveError -> Typed.TypedTerm Errors.ResolutionError+resolutionErrorNoSuchPrimitive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "noSuchPrimitive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the other variant of hydra.errors.ResolutionError+resolutionErrorOther :: Typed.TypedTerm Errors.OtherResolutionError -> Typed.TypedTerm Errors.ResolutionError+resolutionErrorOther x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "other"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unexpectedShape variant of hydra.errors.ResolutionError+resolutionErrorUnexpectedShape :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm Errors.ResolutionError+resolutionErrorUnexpectedShape x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unexpectedShape"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL accessor for the body of hydra.errors.DecodingError+unDecodingError :: Typed.TypedTerm Errors.DecodingError -> Typed.TypedTerm String+unDecodingError x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.DecodingError")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.errors.OtherError+unOtherError :: Typed.TypedTerm Errors.OtherError -> Typed.TypedTerm String+unOtherError x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.OtherError")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.errors.OtherResolutionError+unOtherResolutionError :: Typed.TypedTerm Errors.OtherResolutionError -> Typed.TypedTerm String+unOtherResolutionError x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.OtherResolutionError")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.errors.UnexpectedShapeError+unexpectedShapeError :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Errors.UnexpectedShapeError+unexpectedShapeError expected actual =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expected"),+          Core.fieldTerm = (Typed.unTypedTerm expected)},+        Core.Field {+          Core.fieldName = (Core.Name "actual"),+          Core.fieldTerm = (Typed.unTypedTerm actual)}]}))+-- | DSL accessor for the actual field of hydra.errors.UnexpectedShapeError+unexpectedShapeErrorActual :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm String+unexpectedShapeErrorActual x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+        Core.projectionFieldName = (Core.Name "actual")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the expected field of hydra.errors.UnexpectedShapeError+unexpectedShapeErrorExpected :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm String+unexpectedShapeErrorExpected x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+        Core.projectionFieldName = (Core.Name "expected")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the actual field of hydra.errors.UnexpectedShapeError+unexpectedShapeErrorWithActual :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm String -> Typed.TypedTerm Errors.UnexpectedShapeError+unexpectedShapeErrorWithActual original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expected"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+              Core.projectionFieldName = (Core.Name "expected")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "actual"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the expected field of hydra.errors.UnexpectedShapeError+unexpectedShapeErrorWithExpected :: Typed.TypedTerm Errors.UnexpectedShapeError -> Typed.TypedTerm String -> Typed.TypedTerm Errors.UnexpectedShapeError+unexpectedShapeErrorWithExpected original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expected"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "actual"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+              Core.projectionFieldName = (Core.Name "actual")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.errors.UnificationError+unificationError :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm String -> Typed.TypedTerm Errors.UnificationError+unificationError leftType rightType message =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "leftType"),+          Core.fieldTerm = (Typed.unTypedTerm leftType)},+        Core.Field {+          Core.fieldName = (Core.Name "rightType"),+          Core.fieldTerm = (Typed.unTypedTerm rightType)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm message)}]}))+-- | DSL accessor for the leftType field of hydra.errors.UnificationError+unificationErrorLeftType :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Core.Type+unificationErrorLeftType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+        Core.projectionFieldName = (Core.Name "leftType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the message field of hydra.errors.UnificationError+unificationErrorMessage :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm String+unificationErrorMessage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+        Core.projectionFieldName = (Core.Name "message")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the rightType field of hydra.errors.UnificationError+unificationErrorRightType :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Core.Type+unificationErrorRightType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+        Core.projectionFieldName = (Core.Name "rightType")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the leftType field of hydra.errors.UnificationError+unificationErrorWithLeftType :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Errors.UnificationError+unificationErrorWithLeftType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "leftType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "rightType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+              Core.projectionFieldName = (Core.Name "rightType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the message field of hydra.errors.UnificationError+unificationErrorWithMessage :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm String -> Typed.TypedTerm Errors.UnificationError+unificationErrorWithMessage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "leftType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+              Core.projectionFieldName = (Core.Name "leftType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rightType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+              Core.projectionFieldName = (Core.Name "rightType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the rightType field of hydra.errors.UnificationError+unificationErrorWithRightType :: Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Errors.UnificationError+unificationErrorWithRightType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "leftType"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+              Core.projectionFieldName = (Core.Name "leftType")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "rightType"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.errors.UnificationInferenceError+unificationInferenceError :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Errors.UnificationInferenceError+unificationInferenceError path cause =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "cause"),+          Core.fieldTerm = (Typed.unTypedTerm cause)}]}))+-- | DSL accessor for the cause field of hydra.errors.UnificationInferenceError+unificationInferenceErrorCause :: Typed.TypedTerm Errors.UnificationInferenceError -> Typed.TypedTerm Errors.UnificationError+unificationInferenceErrorCause x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+        Core.projectionFieldName = (Core.Name "cause")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the path field of hydra.errors.UnificationInferenceError+unificationInferenceErrorPath :: Typed.TypedTerm Errors.UnificationInferenceError -> Typed.TypedTerm Paths.SubtermPath+unificationInferenceErrorPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the cause field of hydra.errors.UnificationInferenceError+unificationInferenceErrorWithCause :: Typed.TypedTerm Errors.UnificationInferenceError -> Typed.TypedTerm Errors.UnificationError -> Typed.TypedTerm Errors.UnificationInferenceError+unificationInferenceErrorWithCause original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "cause"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the path field of hydra.errors.UnificationInferenceError+unificationInferenceErrorWithPath :: Typed.TypedTerm Errors.UnificationInferenceError -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Errors.UnificationInferenceError+unificationInferenceErrorWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "cause"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+              Core.projectionFieldName = (Core.Name "cause")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+ src/main/haskell/Hydra/Dsl/Graph.hs view
@@ -0,0 +1,852 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.graph++module Hydra.Dsl.Graph where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Errors as DslErrors+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | DSL constructor for hydra.graph.Graph+graph :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm (M.Map Core.Name Graph.Primitive) -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Graph.Graph+graph boundTerms boundTypes classConstraints lambdaVariables metadata primitives schemaTypes typeVariables =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Typed.unTypedTerm boundTerms)},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Typed.unTypedTerm boundTypes)},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Typed.unTypedTerm classConstraints)},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Typed.unTypedTerm lambdaVariables)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm metadata)},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Typed.unTypedTerm primitives)},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Typed.unTypedTerm schemaTypes)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Typed.unTypedTerm typeVariables)}]}))+-- | DSL accessor for the boundTerms field of hydra.graph.Graph+graphBoundTerms :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term)+graphBoundTerms x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "boundTerms")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the boundTypes field of hydra.graph.Graph+graphBoundTypes :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme)+graphBoundTypes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "boundTypes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the classConstraints field of hydra.graph.Graph+graphClassConstraints :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints)+graphClassConstraints x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "classConstraints")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the lambdaVariables field of hydra.graph.Graph+graphLambdaVariables :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Core.Name)+graphLambdaVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "lambdaVariables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the metadata field of hydra.graph.Graph+graphMetadata :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term)+graphMetadata x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "metadata")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the primitives field of hydra.graph.Graph+graphPrimitives :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Graph.Primitive)+graphPrimitives x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "primitives")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the schemaTypes field of hydra.graph.Graph+graphSchemaTypes :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme)+graphSchemaTypes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "schemaTypes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeVariables field of hydra.graph.Graph+graphTypeVariables :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Core.Name)+graphTypeVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+        Core.projectionFieldName = (Core.Name "typeVariables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the boundTerms field of hydra.graph.Graph+graphWithBoundTerms :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm Graph.Graph+graphWithBoundTerms original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "lambdaVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "schemaTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the boundTypes field of hydra.graph.Graph+graphWithBoundTypes :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm Graph.Graph+graphWithBoundTypes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTerms")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "lambdaVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "schemaTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the classConstraints field of hydra.graph.Graph+graphWithClassConstraints :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints) -> Typed.TypedTerm Graph.Graph+graphWithClassConstraints original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTerms")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "lambdaVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "schemaTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the lambdaVariables field of hydra.graph.Graph+graphWithLambdaVariables :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Graph.Graph+graphWithLambdaVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTerms")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "schemaTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the metadata field of hydra.graph.Graph+graphWithMetadata :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm Graph.Graph+graphWithMetadata original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTerms")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "lambdaVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "schemaTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the primitives field of hydra.graph.Graph+graphWithPrimitives :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Graph.Primitive) -> Typed.TypedTerm Graph.Graph+graphWithPrimitives original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTerms")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "lambdaVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "schemaTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the schemaTypes field of hydra.graph.Graph+graphWithSchemaTypes :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (M.Map Core.Name Core.TypeScheme) -> Typed.TypedTerm Graph.Graph+graphWithSchemaTypes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTerms")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "lambdaVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "typeVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeVariables field of hydra.graph.Graph+graphWithTypeVariables :: Typed.TypedTerm Graph.Graph -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Graph.Graph+graphWithTypeVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Graph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "boundTerms"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTerms")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "boundTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "boundTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lambdaVariables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "lambdaVariables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "schemaTypes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Graph"),+              Core.projectionFieldName = (Core.Name "schemaTypes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.graph.Library+library :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm String -> Typed.TypedTerm [Graph.Primitive] -> Typed.TypedTerm Graph.Library+library name prefix primitives =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Library"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Typed.unTypedTerm prefix)},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Typed.unTypedTerm primitives)}]}))+-- | DSL accessor for the name field of hydra.graph.Library+libraryName :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm Packaging.ModuleName+libraryName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the prefix field of hydra.graph.Library+libraryPrefix :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm String+libraryPrefix x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+        Core.projectionFieldName = (Core.Name "prefix")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the primitives field of hydra.graph.Library+libraryPrimitives :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm [Graph.Primitive]+libraryPrimitives x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+        Core.projectionFieldName = (Core.Name "primitives")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.graph.Library+libraryWithName :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Graph.Library+libraryWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Library"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+              Core.projectionFieldName = (Core.Name "prefix")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the prefix field of hydra.graph.Library+libraryWithPrefix :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm String -> Typed.TypedTerm Graph.Library+libraryWithPrefix original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Library"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "primitives"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+              Core.projectionFieldName = (Core.Name "primitives")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the primitives field of hydra.graph.Library+libraryWithPrimitives :: Typed.TypedTerm Graph.Library -> Typed.TypedTerm [Graph.Primitive] -> Typed.TypedTerm Graph.Library+libraryWithPrimitives original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Library"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "prefix"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Library"),+              Core.projectionFieldName = (Core.Name "prefix")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          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 definition implementation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Primitive"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definition"),+          Core.fieldTerm = (Typed.unTypedTerm definition)},+        Core.Field {+          Core.fieldName = (Core.Name "implementation"),+          Core.fieldTerm = (Typed.unTypedTerm implementation)}]}))+-- | DSL accessor for the definition field of hydra.graph.Primitive+primitiveDefinition :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinition x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"),+        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 x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"),+        Core.projectionFieldName = (Core.Name "implementation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the definition field of hydra.graph.Primitive+primitiveWithDefinition :: Typed.TypedTerm Graph.Primitive -> Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Graph.Primitive+primitiveWithDefinition original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Primitive"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definition"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "implementation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"),+              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 original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.Primitive"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "definition"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.Primitive"),+              Core.projectionFieldName = (Core.Name "definition")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "implementation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.graph.TermCoder+termCoder :: Typed.TypedTerm Core.Type -> Typed.TypedTerm (Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error a) -> Typed.TypedTerm (Typing.InferenceContext -> a -> Either Errors.Error Core.Term) -> Typed.TypedTerm (Graph.TermCoder a)+termCoder type_ encode decode =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm encode)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm decode)}]}))+-- | DSL accessor for the decode field of hydra.graph.TermCoder+termCoderDecode :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm (Typing.InferenceContext -> a -> Either Errors.Error Core.Term)+termCoderDecode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+        Core.projectionFieldName = (Core.Name "decode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the encode field of hydra.graph.TermCoder+termCoderEncode :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm (Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error a)+termCoderEncode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+        Core.projectionFieldName = (Core.Name "encode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.graph.TermCoder+termCoderType :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm Core.Type+termCoderType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the decode field of hydra.graph.TermCoder+termCoderWithDecode :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm (Typing.InferenceContext -> a -> Either Errors.Error Core.Term) -> Typed.TypedTerm (Graph.TermCoder a)+termCoderWithDecode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+              Core.projectionFieldName = (Core.Name "encode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the encode field of hydra.graph.TermCoder+termCoderWithEncode :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm (Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error a) -> Typed.TypedTerm (Graph.TermCoder a)+termCoderWithEncode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+              Core.projectionFieldName = (Core.Name "decode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.graph.TermCoder+termCoderWithType :: Typed.TypedTerm (Graph.TermCoder a) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm (Graph.TermCoder a)+termCoderWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.graph.TermCoder"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+              Core.projectionFieldName = (Core.Name "encode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.graph.TermCoder"),+              Core.projectionFieldName = (Core.Name "decode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+ src/main/haskell/Hydra/Dsl/Json/Model.hs view
@@ -0,0 +1,58 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.json.model++module Hydra.Dsl.Json.Model where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Json.Model as Model+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL injection for the array variant of hydra.json.model.Value+valueArray :: Typed.TypedTerm [Model.Value] -> Typed.TypedTerm Model.Value+valueArray x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "array"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the boolean variant of hydra.json.model.Value+valueBoolean :: Typed.TypedTerm Bool -> Typed.TypedTerm Model.Value+valueBoolean x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "boolean"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the null variant of hydra.json.model.Value+valueNull :: Typed.TypedTerm Model.Value+valueNull =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "null"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the number variant of hydra.json.model.Value+valueNumber :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm Model.Value+valueNumber x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "number"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the object variant of hydra.json.model.Value+valueObject :: Typed.TypedTerm [(String, Model.Value)] -> Typed.TypedTerm Model.Value+valueObject x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "object"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the string variant of hydra.json.model.Value+valueString :: Typed.TypedTerm String -> Typed.TypedTerm Model.Value+valueString x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "string"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+ src/main/haskell/Hydra/Dsl/Literals.hs view
@@ -0,0 +1,95 @@+-- | A DSL for constructing Hydra literal values in Haskell++module Hydra.Dsl.Literals where++import Hydra.Core++import Data.Int+import qualified Data.ByteString as B+import qualified Data.Scientific as Sci+++-- | Create an arbitrary-precision integer literal+-- Example: bigint 9223372036854775808+bigint :: Integer -> Literal+bigint = integer . IntegerValueBigint . fromIntegral++-- | Create a binary data literal+-- Example: binary (B.pack [0x48, 0x65, 0x6C, 0x6C, 0x6F])+binary :: B.ByteString -> Literal+binary = LiteralBinary++-- | Create a boolean literal+-- Example: boolean True+boolean :: Bool -> Literal+boolean = LiteralBoolean++-- | Create an arbitrary-precision decimal literal+-- Example: decimal (Sci.scientific 314159265359 (-11))+decimal :: Sci.Scientific -> Literal+decimal = LiteralDecimal++-- | Create a floating-point literal with specified precision+-- Example: float (FloatValueFloat32 3.14)+float :: FloatValue -> Literal+float = LiteralFloat++-- | Create a 32-bit floating point literal+-- Example: float32 3.14+float32 :: Float -> Literal+float32 = float . FloatValueFloat32++-- | Create a 64-bit floating point literal+-- Example: float64 3.14159265359+float64 :: Double -> Literal+float64 = float . FloatValueFloat64++-- | Create a 16-bit signed integer literal+-- Example: int16 32767+int16 :: Int16 -> Literal+int16 = integer . IntegerValueInt16 . fromIntegral++-- | Create a 32-bit signed integer literal+-- Example: int32 42+int32 :: Int -> Literal+int32 = integer . IntegerValueInt32++-- | Create a 64-bit signed integer literal+-- Example: int64 9223372036854775807+int64 :: Int64 -> Literal+int64 = integer . IntegerValueInt64 . fromIntegral++-- | Create an 8-bit signed integer literal+-- Example: int8 127+int8 :: Int8 -> Literal+int8 = integer . IntegerValueInt8 . fromIntegral++-- | Create an integer literal with specified bit width+-- Example: integer (IntegerValueInt32 42)+integer :: IntegerValue -> Literal+integer = LiteralInteger++-- | Create a string literal+-- Example: string "hello world"+string :: String -> Literal+string = LiteralString++-- | Create a 16-bit unsigned integer literal+-- Example: uint16 65535+uint16 :: Int -> Literal+uint16 = integer . IntegerValueUint16 . fromIntegral++-- | Create a 32-bit unsigned integer literal+-- Example: uint32 4294967295+uint32 :: Int64 -> Literal+uint32 = integer . IntegerValueUint32 . fromIntegral++-- | Create a 64-bit unsigned integer literal+-- Example: uint64 18446744073709551615+uint64 :: Integer -> Literal+uint64 = integer . IntegerValueUint64 . fromIntegral++-- | Create an 8-bit unsigned integer literal+-- Example: uint8 255+uint8 :: Int16 -> Literal+uint8 = integer . IntegerValueUint8 . fromIntegral
+ src/main/haskell/Hydra/Dsl/Meta/Common.hs view
@@ -0,0 +1,15 @@+{-# LANGUAGE FlexibleInstances #-}++-- | Common IsString instances for Term and Type, enabling OverloadedStrings++module Hydra.Dsl.Meta.Common where++import Hydra.Core+import Hydra.Typed++import Data.String(IsString(..))+++instance IsString Type where fromString = TypeVariable . Name+instance IsString Term where fromString = TermLiteral . LiteralString+instance IsString (TypedTerm a) where fromString = TypedTerm . TermLiteral . LiteralString
+ src/main/haskell/Hydra/Dsl/Packaging.hs view
@@ -0,0 +1,1432 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.packaging++module Hydra.Dsl.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Typing as DslTyping+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL injection for the primitive variant of hydra.packaging.Definition+definitionPrimitive :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Packaging.Definition+definitionPrimitive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primitive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the primitive variant of hydra.packaging.DefinitionReference+definitionReferencePrimitive :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.DefinitionReference+definitionReferencePrimitive x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "primitive"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the term variant of hydra.packaging.DefinitionReference+definitionReferenceTerm :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.DefinitionReference+definitionReferenceTerm x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "term"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the type variant of hydra.packaging.DefinitionReference+definitionReferenceType :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.DefinitionReference+definitionReferenceType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "type"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the term variant of hydra.packaging.Definition+definitionTerm :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm Packaging.Definition+definitionTerm x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "term"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the type variant of hydra.packaging.Definition+definitionType :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm Packaging.Definition+definitionType x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "type"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.packaging.EntityMetadata+entityMetadata :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [String] -> Typed.TypedTerm [Packaging.EntityReference] -> Typed.TypedTerm (Maybe Packaging.LifecycleInfo) -> Typed.TypedTerm Packaging.EntityMetadata+entityMetadata description comments seeAlso lifecycle =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)},+        Core.Field {+          Core.fieldName = (Core.Name "comments"),+          Core.fieldTerm = (Typed.unTypedTerm comments)},+        Core.Field {+          Core.fieldName = (Core.Name "seeAlso"),+          Core.fieldTerm = (Typed.unTypedTerm seeAlso)},+        Core.Field {+          Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = (Typed.unTypedTerm lifecycle)}]}))+-- | DSL accessor for the comments field of hydra.packaging.EntityMetadata+entityMetadataComments :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [String]+entityMetadataComments x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+        Core.projectionFieldName = (Core.Name "comments")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the description field of hydra.packaging.EntityMetadata+entityMetadataDescription :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm (Maybe String)+entityMetadataDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the lifecycle field of hydra.packaging.EntityMetadata+entityMetadataLifecycle :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm (Maybe Packaging.LifecycleInfo)+entityMetadataLifecycle x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+        Core.projectionFieldName = (Core.Name "lifecycle")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the seeAlso field of hydra.packaging.EntityMetadata+entityMetadataSeeAlso :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [Packaging.EntityReference]+entityMetadataSeeAlso x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+        Core.projectionFieldName = (Core.Name "seeAlso")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the comments field of hydra.packaging.EntityMetadata+entityMetadataWithComments :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [String] -> Typed.TypedTerm Packaging.EntityMetadata+entityMetadataWithComments original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "comments"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "seeAlso"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "seeAlso")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "lifecycle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the description field of hydra.packaging.EntityMetadata+entityMetadataWithDescription :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Packaging.EntityMetadata+entityMetadataWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "comments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "comments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "seeAlso"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "seeAlso")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "lifecycle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the lifecycle field of hydra.packaging.EntityMetadata+entityMetadataWithLifecycle :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm (Maybe Packaging.LifecycleInfo) -> Typed.TypedTerm Packaging.EntityMetadata+entityMetadataWithLifecycle original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "comments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "comments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "seeAlso"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "seeAlso")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the seeAlso field of hydra.packaging.EntityMetadata+entityMetadataWithSeeAlso :: Typed.TypedTerm Packaging.EntityMetadata -> Typed.TypedTerm [Packaging.EntityReference] -> Typed.TypedTerm Packaging.EntityMetadata+entityMetadataWithSeeAlso original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "comments"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "comments")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "seeAlso"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+              Core.projectionFieldName = (Core.Name "lifecycle")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the definition variant of hydra.packaging.EntityReference+entityReferenceDefinition :: Typed.TypedTerm Packaging.DefinitionReference -> Typed.TypedTerm Packaging.EntityReference+entityReferenceDefinition x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "definition"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the module variant of hydra.packaging.EntityReference+entityReferenceModule :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.EntityReference+entityReferenceModule x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "module"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the package variant of hydra.packaging.EntityReference+entityReferencePackage :: Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Packaging.EntityReference+entityReferencePackage x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "package"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.packaging.LifecycleInfo+lifecycleInfo :: Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Packaging.LifecycleInfo+lifecycleInfo availableSince deprecatedSince =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "availableSince"),+          Core.fieldTerm = (Typed.unTypedTerm availableSince)},+        Core.Field {+          Core.fieldName = (Core.Name "deprecatedSince"),+          Core.fieldTerm = (Typed.unTypedTerm deprecatedSince)}]}))+-- | DSL accessor for the availableSince field of hydra.packaging.LifecycleInfo+lifecycleInfoAvailableSince :: Typed.TypedTerm Packaging.LifecycleInfo -> Typed.TypedTerm (Maybe Packaging.Version)+lifecycleInfoAvailableSince x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+        Core.projectionFieldName = (Core.Name "availableSince")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the deprecatedSince field of hydra.packaging.LifecycleInfo+lifecycleInfoDeprecatedSince :: Typed.TypedTerm Packaging.LifecycleInfo -> Typed.TypedTerm (Maybe Packaging.Version)+lifecycleInfoDeprecatedSince x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+        Core.projectionFieldName = (Core.Name "deprecatedSince")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the availableSince field of hydra.packaging.LifecycleInfo+lifecycleInfoWithAvailableSince :: Typed.TypedTerm Packaging.LifecycleInfo -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Packaging.LifecycleInfo+lifecycleInfoWithAvailableSince original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "availableSince"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "deprecatedSince"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+              Core.projectionFieldName = (Core.Name "deprecatedSince")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the deprecatedSince field of hydra.packaging.LifecycleInfo+lifecycleInfoWithDeprecatedSince :: Typed.TypedTerm Packaging.LifecycleInfo -> Typed.TypedTerm (Maybe Packaging.Version) -> Typed.TypedTerm Packaging.LifecycleInfo+lifecycleInfoWithDeprecatedSince original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "availableSince"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+              Core.projectionFieldName = (Core.Name "availableSince")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "deprecatedSince"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.packaging.Module+module_ :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm [Packaging.ModuleDependency] -> Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm Packaging.Module+module_ name metadata dependencies definitions =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Module"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm metadata)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Typed.unTypedTerm dependencies)},+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Typed.unTypedTerm definitions)}]}))+-- | DSL accessor for the definitions field of hydra.packaging.Module+moduleDefinitions :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm [Packaging.Definition]+moduleDefinitions x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+        Core.projectionFieldName = (Core.Name "definitions")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the dependencies field of hydra.packaging.Module+moduleDependencies :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm [Packaging.ModuleDependency]+moduleDependencies x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+        Core.projectionFieldName = (Core.Name "dependencies")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.packaging.ModuleDependency+moduleDependency :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm (Maybe Packaging.PackageName) -> Typed.TypedTerm Packaging.ModuleDependency+moduleDependency module_ package =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Typed.unTypedTerm module_)},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Typed.unTypedTerm package)}]}))+-- | DSL accessor for the module field of hydra.packaging.ModuleDependency+moduleDependencyModule :: Typed.TypedTerm Packaging.ModuleDependency -> Typed.TypedTerm Packaging.ModuleName+moduleDependencyModule x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+        Core.projectionFieldName = (Core.Name "module")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the package field of hydra.packaging.ModuleDependency+moduleDependencyPackage :: Typed.TypedTerm Packaging.ModuleDependency -> Typed.TypedTerm (Maybe Packaging.PackageName)+moduleDependencyPackage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+        Core.projectionFieldName = (Core.Name "package")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the module field of hydra.packaging.ModuleDependency+moduleDependencyWithModule :: Typed.TypedTerm Packaging.ModuleDependency -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.ModuleDependency+moduleDependencyWithModule original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+              Core.projectionFieldName = (Core.Name "package")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the package field of hydra.packaging.ModuleDependency+moduleDependencyWithPackage :: Typed.TypedTerm Packaging.ModuleDependency -> Typed.TypedTerm (Maybe Packaging.PackageName) -> Typed.TypedTerm Packaging.ModuleDependency+moduleDependencyWithPackage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+              Core.projectionFieldName = (Core.Name "module")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL accessor for the metadata field of hydra.packaging.Module+moduleMetadata :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm (Maybe Packaging.EntityMetadata)+moduleMetadata x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+        Core.projectionFieldName = (Core.Name "metadata")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.packaging.Module+moduleName :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Packaging.ModuleName+moduleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.packaging.ModuleName wrapper+moduleName2 :: Typed.TypedTerm String -> Typed.TypedTerm Packaging.ModuleName+moduleName2 x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.packaging.ModuleName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL updater for the definitions field of hydra.packaging.Module+moduleWithDefinitions :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm [Packaging.Definition] -> Typed.TypedTerm Packaging.Module+moduleWithDefinitions original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Module"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the dependencies field of hydra.packaging.Module+moduleWithDependencies :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm [Packaging.ModuleDependency] -> Typed.TypedTerm Packaging.Module+moduleWithDependencies original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Module"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "definitions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the metadata field of hydra.packaging.Module+moduleWithMetadata :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm Packaging.Module+moduleWithMetadata original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Module"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "definitions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.packaging.Module+moduleWithName :: Typed.TypedTerm Packaging.Module -> Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm Packaging.Module+moduleWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Module"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+              Core.projectionFieldName = (Core.Name "definitions")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.packaging.Package+package :: Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm [Packaging.PackageDependency] -> Typed.TypedTerm [Packaging.Module] -> Typed.TypedTerm Packaging.Package+package name metadata dependencies modules =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Package"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm metadata)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Typed.unTypedTerm dependencies)},+        Core.Field {+          Core.fieldName = (Core.Name "modules"),+          Core.fieldTerm = (Typed.unTypedTerm modules)}]}))+-- | DSL accessor for the dependencies field of hydra.packaging.Package+packageDependencies :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm [Packaging.PackageDependency]+packageDependencies x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+        Core.projectionFieldName = (Core.Name "dependencies")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.packaging.PackageDependency+packageDependency :: Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Packaging.VersionSpecifier -> Typed.TypedTerm Packaging.PackageDependency+packageDependency name version =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PackageDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Typed.unTypedTerm version)}]}))+-- | DSL accessor for the name field of hydra.packaging.PackageDependency+packageDependencyName :: Typed.TypedTerm Packaging.PackageDependency -> Typed.TypedTerm Packaging.PackageName+packageDependencyName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the version field of hydra.packaging.PackageDependency+packageDependencyVersion :: Typed.TypedTerm Packaging.PackageDependency -> Typed.TypedTerm Packaging.VersionSpecifier+packageDependencyVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"),+        Core.projectionFieldName = (Core.Name "version")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.packaging.PackageDependency+packageDependencyWithName :: Typed.TypedTerm Packaging.PackageDependency -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Packaging.PackageDependency+packageDependencyWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PackageDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"),+              Core.projectionFieldName = (Core.Name "version")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the version field of hydra.packaging.PackageDependency+packageDependencyWithVersion :: Typed.TypedTerm Packaging.PackageDependency -> Typed.TypedTerm Packaging.VersionSpecifier -> Typed.TypedTerm Packaging.PackageDependency+packageDependencyWithVersion original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PackageDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL accessor for the metadata field of hydra.packaging.Package+packageMetadata :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm (Maybe Packaging.EntityMetadata)+packageMetadata x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+        Core.projectionFieldName = (Core.Name "metadata")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the modules field of hydra.packaging.Package+packageModules :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm [Packaging.Module]+packageModules x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+        Core.projectionFieldName = (Core.Name "modules")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.packaging.Package+packageName :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm Packaging.PackageName+packageName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.packaging.PackageName wrapper+packageName2 :: Typed.TypedTerm String -> Typed.TypedTerm Packaging.PackageName+packageName2 x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.packaging.PackageName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL updater for the dependencies field of hydra.packaging.Package+packageWithDependencies :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm [Packaging.PackageDependency] -> Typed.TypedTerm Packaging.Package+packageWithDependencies original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Package"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "modules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "modules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the metadata field of hydra.packaging.Package+packageWithMetadata :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm Packaging.Package+packageWithMetadata original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Package"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "modules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "modules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the modules field of hydra.packaging.Package+packageWithModules :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm [Packaging.Module] -> Typed.TypedTerm Packaging.Package+packageWithModules original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Package"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "modules"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.packaging.Package+packageWithName :: Typed.TypedTerm Packaging.Package -> Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm Packaging.Package+packageWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Package"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "dependencies")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "modules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+              Core.projectionFieldName = (Core.Name "modules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.packaging.PrimitiveDefinition+primitiveDefinition :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm Bool -> Typed.TypedTerm Bool -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinition name metadata signature isPure isTotal defaultImplementation =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm metadata)},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Typed.unTypedTerm signature)},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = (Typed.unTypedTerm isPure)},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = (Typed.unTypedTerm isTotal)},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = (Typed.unTypedTerm defaultImplementation)}]}))+-- | DSL accessor for the defaultImplementation field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionDefaultImplementation :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm (Maybe Core.Term)+primitiveDefinitionDefaultImplementation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+        Core.projectionFieldName = (Core.Name "defaultImplementation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the isPure field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionIsPure :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Bool+primitiveDefinitionIsPure x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+        Core.projectionFieldName = (Core.Name "isPure")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the isTotal field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionIsTotal :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Bool+primitiveDefinitionIsTotal x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+        Core.projectionFieldName = (Core.Name "isTotal")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the metadata field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionMetadata :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm (Maybe Packaging.EntityMetadata)+primitiveDefinitionMetadata x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+        Core.projectionFieldName = (Core.Name "metadata")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionName :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Core.Name+primitiveDefinitionName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the signature field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionSignature :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Typing.TermSignature+primitiveDefinitionSignature x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+        Core.projectionFieldName = (Core.Name "signature")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the defaultImplementation field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionWithDefaultImplementation :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm (Maybe Core.Term) -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinitionWithDefaultImplementation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isPure")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isTotal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the isPure field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionWithIsPure :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Bool -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinitionWithIsPure original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isTotal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "defaultImplementation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the isTotal field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionWithIsTotal :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Bool -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinitionWithIsTotal original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isPure")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "defaultImplementation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the metadata field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionWithMetadata :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinitionWithMetadata original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isPure")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isTotal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "defaultImplementation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionWithName :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinitionWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isPure")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isTotal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "defaultImplementation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the signature field of hydra.packaging.PrimitiveDefinition+primitiveDefinitionWithSignature :: Typed.TypedTerm Packaging.PrimitiveDefinition -> Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm Packaging.PrimitiveDefinition+primitiveDefinitionWithSignature original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isPure")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "isTotal")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+              Core.projectionFieldName = (Core.Name "defaultImplementation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.packaging.TermDefinition+termDefinition :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm (Maybe Typing.TermSignature) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Packaging.TermDefinition+termDefinition name metadata signature body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm metadata)},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Typed.unTypedTerm signature)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))+-- | DSL accessor for the body field of hydra.packaging.TermDefinition+termDefinitionBody :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm Core.Term+termDefinitionBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the metadata field of hydra.packaging.TermDefinition+termDefinitionMetadata :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm (Maybe Packaging.EntityMetadata)+termDefinitionMetadata x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+        Core.projectionFieldName = (Core.Name "metadata")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.packaging.TermDefinition+termDefinitionName :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm Core.Name+termDefinitionName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the signature field of hydra.packaging.TermDefinition+termDefinitionSignature :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm (Maybe Typing.TermSignature)+termDefinitionSignature x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+        Core.projectionFieldName = (Core.Name "signature")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.packaging.TermDefinition+termDefinitionWithBody :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Packaging.TermDefinition+termDefinitionWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the metadata field of hydra.packaging.TermDefinition+termDefinitionWithMetadata :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm Packaging.TermDefinition+termDefinitionWithMetadata original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.packaging.TermDefinition+termDefinitionWithName :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.TermDefinition+termDefinitionWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "signature")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the signature field of hydra.packaging.TermDefinition+termDefinitionWithSignature :: Typed.TypedTerm Packaging.TermDefinition -> Typed.TypedTerm (Maybe Typing.TermSignature) -> Typed.TypedTerm Packaging.TermDefinition+termDefinitionWithSignature original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.packaging.TypeDefinition+typeDefinition :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Packaging.TypeDefinition+typeDefinition name metadata body =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm metadata)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)}]}))+-- | DSL accessor for the body field of hydra.packaging.TypeDefinition+typeDefinitionBody :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm Core.TypeScheme+typeDefinitionBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the metadata field of hydra.packaging.TypeDefinition+typeDefinitionMetadata :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm (Maybe Packaging.EntityMetadata)+typeDefinitionMetadata x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+        Core.projectionFieldName = (Core.Name "metadata")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.packaging.TypeDefinition+typeDefinitionName :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm Core.Name+typeDefinitionName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the body field of hydra.packaging.TypeDefinition+typeDefinitionWithBody :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm Core.TypeScheme -> Typed.TypedTerm Packaging.TypeDefinition+typeDefinitionWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the metadata field of hydra.packaging.TypeDefinition+typeDefinitionWithMetadata :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm (Maybe Packaging.EntityMetadata) -> Typed.TypedTerm Packaging.TypeDefinition+typeDefinitionWithMetadata original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.packaging.TypeDefinition+typeDefinitionWithName :: Typed.TypedTerm Packaging.TypeDefinition -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Packaging.TypeDefinition+typeDefinitionWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+              Core.projectionFieldName = (Core.Name "metadata")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL accessor for the body of hydra.packaging.ModuleName+unModuleName :: Typed.TypedTerm Packaging.ModuleName -> Typed.TypedTerm String+unModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.ModuleName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.packaging.PackageName+unPackageName :: Typed.TypedTerm Packaging.PackageName -> Typed.TypedTerm String+unPackageName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.PackageName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.packaging.Version+unVersion :: Typed.TypedTerm Packaging.Version -> Typed.TypedTerm String+unVersion x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.Version")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.packaging.Version wrapper+version :: Typed.TypedTerm String -> Typed.TypedTerm Packaging.Version+version x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.packaging.Version"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the any variant of hydra.packaging.VersionSpecifier+versionSpecifierAny :: Typed.TypedTerm Packaging.VersionSpecifier+versionSpecifierAny =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.packaging.VersionSpecifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "any"),+        Core.fieldTerm = Core.TermUnit}}))
+ src/main/haskell/Hydra/Dsl/Parsing.hs view
@@ -0,0 +1,158 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.parsing++module Hydra.Dsl.Parsing where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL constructor for hydra.parsing.ParseError+parseError :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Parsing.ParseError+parseError message remainder =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm message)},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = (Typed.unTypedTerm remainder)}]}))+-- | DSL accessor for the message field of hydra.parsing.ParseError+parseErrorMessage :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String+parseErrorMessage x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"),+        Core.projectionFieldName = (Core.Name "message")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the remainder field of hydra.parsing.ParseError+parseErrorRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String+parseErrorRemainder x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"),+        Core.projectionFieldName = (Core.Name "remainder")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the message field of hydra.parsing.ParseError+parseErrorWithMessage :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String -> Typed.TypedTerm Parsing.ParseError+parseErrorWithMessage original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"),+              Core.projectionFieldName = (Core.Name "remainder")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the remainder field of hydra.parsing.ParseError+parseErrorWithRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String -> Typed.TypedTerm Parsing.ParseError+parseErrorWithRemainder original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"),+              Core.projectionFieldName = (Core.Name "message")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the failure variant of hydra.parsing.ParseResult+parseResultFailure :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm (Parsing.ParseResult a)+parseResultFailure x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "failure"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the success variant of hydra.parsing.ParseResult+parseResultSuccess :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm (Parsing.ParseResult a)+parseResultSuccess x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "success"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.parsing.ParseSuccess+parseSuccess :: Typed.TypedTerm a -> Typed.TypedTerm String -> Typed.TypedTerm (Parsing.ParseSuccess a)+parseSuccess value remainder =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm value)},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = (Typed.unTypedTerm remainder)}]}))+-- | DSL accessor for the remainder field of hydra.parsing.ParseSuccess+parseSuccessRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm String+parseSuccessRemainder x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+        Core.projectionFieldName = (Core.Name "remainder")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the value field of hydra.parsing.ParseSuccess+parseSuccessValue :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm a+parseSuccessValue x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+        Core.projectionFieldName = (Core.Name "value")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the remainder field of hydra.parsing.ParseSuccess+parseSuccessWithRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm String -> Typed.TypedTerm (Parsing.ParseSuccess a)+parseSuccessWithRemainder original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+              Core.projectionFieldName = (Core.Name "value")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the value field of hydra.parsing.ParseSuccess+parseSuccessWithValue :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm a -> Typed.TypedTerm (Parsing.ParseSuccess a)+parseSuccessWithValue original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+              Core.projectionFieldName = (Core.Name "remainder")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.parsing.Parser wrapper+parser :: Typed.TypedTerm (String -> Parsing.ParseResult a) -> Typed.TypedTerm (Parsing.Parser a)+parser x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.parsing.Parser"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.parsing.Parser+unParser :: Typed.TypedTerm (Parsing.Parser a) -> Typed.TypedTerm (String -> Parsing.ParseResult a)+unParser x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.parsing.Parser")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Paths.hs view
@@ -0,0 +1,890 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.paths++module Hydra.Dsl.Paths where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Paths as Paths+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL constructor for hydra.paths.SubtermEdge+subtermEdge :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Paths.SubtermEdge+subtermEdge source path target =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Typed.unTypedTerm source)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm target)}]}))+-- | DSL accessor for the path field of hydra.paths.SubtermEdge+subtermEdgePath :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermPath+subtermEdgePath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the source field of hydra.paths.SubtermEdge+subtermEdgeSource :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermNode+subtermEdgeSource x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+        Core.projectionFieldName = (Core.Name "source")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the target field of hydra.paths.SubtermEdge+subtermEdgeTarget :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermNode+subtermEdgeTarget x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+        Core.projectionFieldName = (Core.Name "target")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the path field of hydra.paths.SubtermEdge+subtermEdgeWithPath :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm Paths.SubtermEdge+subtermEdgeWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+              Core.projectionFieldName = (Core.Name "source")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the source field of hydra.paths.SubtermEdge+subtermEdgeWithSource :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Paths.SubtermEdge+subtermEdgeWithSource original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the target field of hydra.paths.SubtermEdge+subtermEdgeWithTarget :: Typed.TypedTerm Paths.SubtermEdge -> Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Paths.SubtermEdge+subtermEdgeWithTarget original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+              Core.projectionFieldName = (Core.Name "source")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.paths.SubtermGraph+subtermGraph :: Typed.TypedTerm [Paths.SubtermNode] -> Typed.TypedTerm [Paths.SubtermEdge] -> Typed.TypedTerm Paths.SubtermGraph+subtermGraph nodes edges =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = (Typed.unTypedTerm nodes)},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = (Typed.unTypedTerm edges)}]}))+-- | DSL accessor for the edges field of hydra.paths.SubtermGraph+subtermGraphEdges :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermEdge]+subtermGraphEdges x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"),+        Core.projectionFieldName = (Core.Name "edges")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the nodes field of hydra.paths.SubtermGraph+subtermGraphNodes :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermNode]+subtermGraphNodes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"),+        Core.projectionFieldName = (Core.Name "nodes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the edges field of hydra.paths.SubtermGraph+subtermGraphWithEdges :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermEdge] -> Typed.TypedTerm Paths.SubtermGraph+subtermGraphWithEdges original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"),+              Core.projectionFieldName = (Core.Name "nodes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the nodes field of hydra.paths.SubtermGraph+subtermGraphWithNodes :: Typed.TypedTerm Paths.SubtermGraph -> Typed.TypedTerm [Paths.SubtermNode] -> Typed.TypedTerm Paths.SubtermGraph+subtermGraphWithNodes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"),+              Core.projectionFieldName = (Core.Name "edges")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.paths.SubtermNode+subtermNode :: Typed.TypedTerm Core.Name -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtermNode+subtermNode name label id =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Typed.unTypedTerm label)},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Typed.unTypedTerm id)}]}))+-- | DSL accessor for the id field of hydra.paths.SubtermNode+subtermNodeId :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm String+subtermNodeId x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+        Core.projectionFieldName = (Core.Name "id")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the label field of hydra.paths.SubtermNode+subtermNodeLabel :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm String+subtermNodeLabel x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+        Core.projectionFieldName = (Core.Name "label")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.paths.SubtermNode+subtermNodeName :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.Name+subtermNodeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the id field of hydra.paths.SubtermNode+subtermNodeWithId :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtermNode+subtermNodeWithId original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+              Core.projectionFieldName = (Core.Name "label")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the label field of hydra.paths.SubtermNode+subtermNodeWithLabel :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtermNode+subtermNodeWithLabel original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+              Core.projectionFieldName = (Core.Name "id")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.paths.SubtermNode+subtermNodeWithName :: Typed.TypedTerm Paths.SubtermNode -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermNode+subtermNodeWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+              Core.projectionFieldName = (Core.Name "label")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+              Core.projectionFieldName = (Core.Name "id")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.paths.SubtermPath wrapper+subtermPath :: Typed.TypedTerm [Paths.SubtermStep] -> Typed.TypedTerm Paths.SubtermPath+subtermPath x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the annotatedBody variant of hydra.paths.SubtermStep+subtermStepAnnotatedBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepAnnotatedBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotatedBody"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the applicationArgument variant of hydra.paths.SubtermStep+subtermStepApplicationArgument :: Typed.TypedTerm Paths.SubtermStep+subtermStepApplicationArgument =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationArgument"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the applicationFunction variant of hydra.paths.SubtermStep+subtermStepApplicationFunction :: Typed.TypedTerm Paths.SubtermStep+subtermStepApplicationFunction =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationFunction"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the injectionTerm variant of hydra.paths.SubtermStep+subtermStepInjectionTerm :: Typed.TypedTerm Paths.SubtermStep+subtermStepInjectionTerm =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "injectionTerm"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the lambdaBody variant of hydra.paths.SubtermStep+subtermStepLambdaBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepLambdaBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambdaBody"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the letBinding variant of hydra.paths.SubtermStep+subtermStepLetBinding :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep+subtermStepLetBinding x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "letBinding"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the letBody variant of hydra.paths.SubtermStep+subtermStepLetBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepLetBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "letBody"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the listElement variant of hydra.paths.SubtermStep+subtermStepListElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepListElement x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "listElement"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the mapKey variant of hydra.paths.SubtermStep+subtermStepMapKey :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepMapKey x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapKey"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the mapValue variant of hydra.paths.SubtermStep+subtermStepMapValue :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepMapValue x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapValue"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the optionalTerm variant of hydra.paths.SubtermStep+subtermStepOptionalTerm :: Typed.TypedTerm Paths.SubtermStep+subtermStepOptionalTerm =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optionalTerm"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the productTerm variant of hydra.paths.SubtermStep+subtermStepProductTerm :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepProductTerm x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "productTerm"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the recordField variant of hydra.paths.SubtermStep+subtermStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep+subtermStepRecordField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "recordField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the setElement variant of hydra.paths.SubtermStep+subtermStepSetElement :: Typed.TypedTerm Int -> Typed.TypedTerm Paths.SubtermStep+subtermStepSetElement x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "setElement"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the sumTerm variant of hydra.paths.SubtermStep+subtermStepSumTerm :: Typed.TypedTerm Paths.SubtermStep+subtermStepSumTerm =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "sumTerm"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the typeApplicationTerm variant of hydra.paths.SubtermStep+subtermStepTypeApplicationTerm :: Typed.TypedTerm Paths.SubtermStep+subtermStepTypeApplicationTerm =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeApplicationTerm"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the typeLambdaBody variant of hydra.paths.SubtermStep+subtermStepTypeLambdaBody :: Typed.TypedTerm Paths.SubtermStep+subtermStepTypeLambdaBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeLambdaBody"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the unionCasesBranch variant of hydra.paths.SubtermStep+subtermStepUnionCasesBranch :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtermStep+subtermStepUnionCasesBranch x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unionCasesBranch"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the unionCasesDefault variant of hydra.paths.SubtermStep+subtermStepUnionCasesDefault :: Typed.TypedTerm Paths.SubtermStep+subtermStepUnionCasesDefault =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unionCasesDefault"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the wrappedTerm variant of hydra.paths.SubtermStep+subtermStepWrappedTerm :: Typed.TypedTerm Paths.SubtermStep+subtermStepWrappedTerm =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrappedTerm"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for hydra.paths.SubtypeEdge+subtypeEdge :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Paths.SubtypeEdge+subtypeEdge source path target =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Typed.unTypedTerm source)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm target)}]}))+-- | DSL accessor for the path field of hydra.paths.SubtypeEdge+subtypeEdgePath :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypePath+subtypeEdgePath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the source field of hydra.paths.SubtypeEdge+subtypeEdgeSource :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypeNode+subtypeEdgeSource x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+        Core.projectionFieldName = (Core.Name "source")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the target field of hydra.paths.SubtypeEdge+subtypeEdgeTarget :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypeNode+subtypeEdgeTarget x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+        Core.projectionFieldName = (Core.Name "target")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the path field of hydra.paths.SubtypeEdge+subtypeEdgeWithPath :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm Paths.SubtypeEdge+subtypeEdgeWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+              Core.projectionFieldName = (Core.Name "source")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the source field of hydra.paths.SubtypeEdge+subtypeEdgeWithSource :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Paths.SubtypeEdge+subtypeEdgeWithSource original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+              Core.projectionFieldName = (Core.Name "target")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the target field of hydra.paths.SubtypeEdge+subtypeEdgeWithTarget :: Typed.TypedTerm Paths.SubtypeEdge -> Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Paths.SubtypeEdge+subtypeEdgeWithTarget original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+              Core.projectionFieldName = (Core.Name "source")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.paths.SubtypeGraph+subtypeGraph :: Typed.TypedTerm [Paths.SubtypeNode] -> Typed.TypedTerm [Paths.SubtypeEdge] -> Typed.TypedTerm Paths.SubtypeGraph+subtypeGraph nodes edges =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = (Typed.unTypedTerm nodes)},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = (Typed.unTypedTerm edges)}]}))+-- | DSL accessor for the edges field of hydra.paths.SubtypeGraph+subtypeGraphEdges :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeEdge]+subtypeGraphEdges x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+        Core.projectionFieldName = (Core.Name "edges")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the nodes field of hydra.paths.SubtypeGraph+subtypeGraphNodes :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeNode]+subtypeGraphNodes x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+        Core.projectionFieldName = (Core.Name "nodes")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the edges field of hydra.paths.SubtypeGraph+subtypeGraphWithEdges :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeEdge] -> Typed.TypedTerm Paths.SubtypeGraph+subtypeGraphWithEdges original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+              Core.projectionFieldName = (Core.Name "nodes")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the nodes field of hydra.paths.SubtypeGraph+subtypeGraphWithNodes :: Typed.TypedTerm Paths.SubtypeGraph -> Typed.TypedTerm [Paths.SubtypeNode] -> Typed.TypedTerm Paths.SubtypeGraph+subtypeGraphWithNodes original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+              Core.projectionFieldName = (Core.Name "edges")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.paths.SubtypeNode+subtypeNode :: Typed.TypedTerm Core.Name -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtypeNode+subtypeNode name label id =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Typed.unTypedTerm label)},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Typed.unTypedTerm id)}]}))+-- | DSL accessor for the id field of hydra.paths.SubtypeNode+subtypeNodeId :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm String+subtypeNodeId x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+        Core.projectionFieldName = (Core.Name "id")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the label field of hydra.paths.SubtypeNode+subtypeNodeLabel :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm String+subtypeNodeLabel x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+        Core.projectionFieldName = (Core.Name "label")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.paths.SubtypeNode+subtypeNodeName :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Core.Name+subtypeNodeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the id field of hydra.paths.SubtypeNode+subtypeNodeWithId :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtypeNode+subtypeNodeWithId original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+              Core.projectionFieldName = (Core.Name "label")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the label field of hydra.paths.SubtypeNode+subtypeNodeWithLabel :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm String -> Typed.TypedTerm Paths.SubtypeNode+subtypeNodeWithLabel original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+              Core.projectionFieldName = (Core.Name "id")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.paths.SubtypeNode+subtypeNodeWithName :: Typed.TypedTerm Paths.SubtypeNode -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeNode+subtypeNodeWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+              Core.projectionFieldName = (Core.Name "label")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+              Core.projectionFieldName = (Core.Name "id")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.paths.SubtypePath wrapper+subtypePath :: Typed.TypedTerm [Paths.SubtypeStep] -> Typed.TypedTerm Paths.SubtypePath+subtypePath x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the annotatedBody variant of hydra.paths.SubtypeStep+subtypeStepAnnotatedBody :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepAnnotatedBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotatedBody"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the applicationArgument variant of hydra.paths.SubtypeStep+subtypeStepApplicationArgument :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepApplicationArgument =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationArgument"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the applicationFunction variant of hydra.paths.SubtypeStep+subtypeStepApplicationFunction :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepApplicationFunction =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "applicationFunction"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the eitherLeft variant of hydra.paths.SubtypeStep+subtypeStepEitherLeft :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepEitherLeft =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "eitherLeft"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the eitherRight variant of hydra.paths.SubtypeStep+subtypeStepEitherRight :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepEitherRight =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "eitherRight"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the forallBody variant of hydra.paths.SubtypeStep+subtypeStepForallBody :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepForallBody =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "forallBody"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the functionCodomain variant of hydra.paths.SubtypeStep+subtypeStepFunctionCodomain :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepFunctionCodomain =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "functionCodomain"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the functionDomain variant of hydra.paths.SubtypeStep+subtypeStepFunctionDomain :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepFunctionDomain =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "functionDomain"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the listElement variant of hydra.paths.SubtypeStep+subtypeStepListElement :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepListElement =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "listElement"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the mapKeys variant of hydra.paths.SubtypeStep+subtypeStepMapKeys :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepMapKeys =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapKeys"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the mapValues variant of hydra.paths.SubtypeStep+subtypeStepMapValues :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepMapValues =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapValues"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the optionalElement variant of hydra.paths.SubtypeStep+subtypeStepOptionalElement :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepOptionalElement =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optionalElement"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the pairFirst variant of hydra.paths.SubtypeStep+subtypeStepPairFirst :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepPairFirst =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pairFirst"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the pairSecond variant of hydra.paths.SubtypeStep+subtypeStepPairSecond :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepPairSecond =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pairSecond"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the recordField variant of hydra.paths.SubtypeStep+subtypeStepRecordField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep+subtypeStepRecordField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "recordField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the setElement variant of hydra.paths.SubtypeStep+subtypeStepSetElement :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepSetElement =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "setElement"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the unionField variant of hydra.paths.SubtypeStep+subtypeStepUnionField :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Paths.SubtypeStep+subtypeStepUnionField x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unionField"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the wrappedType variant of hydra.paths.SubtypeStep+subtypeStepWrappedType :: Typed.TypedTerm Paths.SubtypeStep+subtypeStepWrappedType =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrappedType"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL accessor for the body of hydra.paths.SubtermPath+unSubtermPath :: Typed.TypedTerm Paths.SubtermPath -> Typed.TypedTerm [Paths.SubtermStep]+unSubtermPath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtermPath")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.paths.SubtypePath+unSubtypePath :: Typed.TypedTerm Paths.SubtypePath -> Typed.TypedTerm [Paths.SubtypeStep]+unSubtypePath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtypePath")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Query.hs view
@@ -0,0 +1,814 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.query++module Hydra.Dsl.Query where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Query as Query+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL injection for the equal variant of hydra.query.ComparisonConstraint+comparisonConstraintEqual :: Typed.TypedTerm Query.ComparisonConstraint+comparisonConstraintEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "equal"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the greaterThan variant of hydra.query.ComparisonConstraint+comparisonConstraintGreaterThan :: Typed.TypedTerm Query.ComparisonConstraint+comparisonConstraintGreaterThan =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "greaterThan"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the greaterThanOrEqual variant of hydra.query.ComparisonConstraint+comparisonConstraintGreaterThanOrEqual :: Typed.TypedTerm Query.ComparisonConstraint+comparisonConstraintGreaterThanOrEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "greaterThanOrEqual"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the lessThan variant of hydra.query.ComparisonConstraint+comparisonConstraintLessThan :: Typed.TypedTerm Query.ComparisonConstraint+comparisonConstraintLessThan =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lessThan"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the lessThanOrEqual variant of hydra.query.ComparisonConstraint+comparisonConstraintLessThanOrEqual :: Typed.TypedTerm Query.ComparisonConstraint+comparisonConstraintLessThanOrEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lessThanOrEqual"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the notEqual variant of hydra.query.ComparisonConstraint+comparisonConstraintNotEqual :: Typed.TypedTerm Query.ComparisonConstraint+comparisonConstraintNotEqual =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "notEqual"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for hydra.query.Edge+edge :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe Core.Name) -> Typed.TypedTerm (Maybe Core.Name) -> Typed.TypedTerm Query.Edge+edge type_ out in_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Edge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "out"),+          Core.fieldTerm = (Typed.unTypedTerm out)},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Typed.unTypedTerm in_)}]}))+-- | DSL accessor for the in field of hydra.query.Edge+edgeIn :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm (Maybe Core.Name)+edgeIn x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+        Core.projectionFieldName = (Core.Name "in")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the out field of hydra.query.Edge+edgeOut :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm (Maybe Core.Name)+edgeOut x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+        Core.projectionFieldName = (Core.Name "out")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.query.Edge+edgeType :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm Core.Name+edgeType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the in field of hydra.query.Edge+edgeWithIn :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm (Maybe Core.Name) -> Typed.TypedTerm Query.Edge+edgeWithIn original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Edge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "out"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+              Core.projectionFieldName = (Core.Name "out")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the out field of hydra.query.Edge+edgeWithOut :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm (Maybe Core.Name) -> Typed.TypedTerm Query.Edge+edgeWithOut original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Edge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "out"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+              Core.projectionFieldName = (Core.Name "in")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.query.Edge+edgeWithType :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Query.Edge+edgeWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Edge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "out"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+              Core.projectionFieldName = (Core.Name "out")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+              Core.projectionFieldName = (Core.Name "in")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.query.GraphPattern+graphPattern :: Typed.TypedTerm Core.Name -> Typed.TypedTerm [Query.Pattern] -> Typed.TypedTerm Query.GraphPattern+graphPattern graph patterns =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm graph)},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Typed.unTypedTerm patterns)}]}))+-- | DSL accessor for the graph field of hydra.query.GraphPattern+graphPatternGraph :: Typed.TypedTerm Query.GraphPattern -> Typed.TypedTerm Core.Name+graphPatternGraph x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"),+        Core.projectionFieldName = (Core.Name "graph")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the patterns field of hydra.query.GraphPattern+graphPatternPatterns :: Typed.TypedTerm Query.GraphPattern -> Typed.TypedTerm [Query.Pattern]+graphPatternPatterns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"),+        Core.projectionFieldName = (Core.Name "patterns")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the graph field of hydra.query.GraphPattern+graphPatternWithGraph :: Typed.TypedTerm Query.GraphPattern -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Query.GraphPattern+graphPatternWithGraph original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"),+              Core.projectionFieldName = (Core.Name "patterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the patterns field of hydra.query.GraphPattern+graphPatternWithPatterns :: Typed.TypedTerm Query.GraphPattern -> Typed.TypedTerm [Query.Pattern] -> Typed.TypedTerm Query.GraphPattern+graphPatternWithPatterns original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"),+              Core.projectionFieldName = (Core.Name "graph")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the term variant of hydra.query.Node+nodeTerm :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Query.Node+nodeTerm x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "term"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the variable variant of hydra.query.Node+nodeVariable :: Typed.TypedTerm Query.Variable -> Typed.TypedTerm Query.Node+nodeVariable x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "variable"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the wildcard variant of hydra.query.Node+nodeWildcard :: Typed.TypedTerm Query.Node+nodeWildcard =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wildcard"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for hydra.query.PathEquation+pathEquation :: Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.PathEquation+pathEquation left right =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PathEquation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm left)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm right)}]}))+-- | DSL accessor for the left field of hydra.query.PathEquation+pathEquationLeft :: Typed.TypedTerm Query.PathEquation -> Typed.TypedTerm Query.Path+pathEquationLeft x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"),+        Core.projectionFieldName = (Core.Name "left")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the right field of hydra.query.PathEquation+pathEquationRight :: Typed.TypedTerm Query.PathEquation -> Typed.TypedTerm Query.Path+pathEquationRight x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"),+        Core.projectionFieldName = (Core.Name "right")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the left field of hydra.query.PathEquation+pathEquationWithLeft :: Typed.TypedTerm Query.PathEquation -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.PathEquation+pathEquationWithLeft original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PathEquation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"),+              Core.projectionFieldName = (Core.Name "right")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the right field of hydra.query.PathEquation+pathEquationWithRight :: Typed.TypedTerm Query.PathEquation -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.PathEquation+pathEquationWithRight original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PathEquation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"),+              Core.projectionFieldName = (Core.Name "left")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the inverse variant of hydra.query.Path+pathInverse :: Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.Path+pathInverse x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Path"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "inverse"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the regex variant of hydra.query.Path+pathRegex :: Typed.TypedTerm Query.RegexSequence -> Typed.TypedTerm Query.Path+pathRegex x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Path"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "regex"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the step variant of hydra.query.Path+pathStep :: Typed.TypedTerm Query.Step -> Typed.TypedTerm Query.Path+pathStep x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Path"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "step"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the conjunction variant of hydra.query.Pattern+patternConjunction :: Typed.TypedTerm [Query.Pattern] -> Typed.TypedTerm Query.Pattern+patternConjunction x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "conjunction"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the disjunction variant of hydra.query.Pattern+patternDisjunction :: Typed.TypedTerm [Query.Pattern] -> Typed.TypedTerm Query.Pattern+patternDisjunction x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "disjunction"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the graph variant of hydra.query.Pattern+patternGraph :: Typed.TypedTerm Query.GraphPattern -> Typed.TypedTerm Query.Pattern+patternGraph x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "graph"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.query.PatternImplication+patternImplication :: Typed.TypedTerm Query.Pattern -> Typed.TypedTerm Query.Pattern -> Typed.TypedTerm Query.PatternImplication+patternImplication antecedent consequent =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "antecedent"),+          Core.fieldTerm = (Typed.unTypedTerm antecedent)},+        Core.Field {+          Core.fieldName = (Core.Name "consequent"),+          Core.fieldTerm = (Typed.unTypedTerm consequent)}]}))+-- | DSL accessor for the antecedent field of hydra.query.PatternImplication+patternImplicationAntecedent :: Typed.TypedTerm Query.PatternImplication -> Typed.TypedTerm Query.Pattern+patternImplicationAntecedent x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"),+        Core.projectionFieldName = (Core.Name "antecedent")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the consequent field of hydra.query.PatternImplication+patternImplicationConsequent :: Typed.TypedTerm Query.PatternImplication -> Typed.TypedTerm Query.Pattern+patternImplicationConsequent x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"),+        Core.projectionFieldName = (Core.Name "consequent")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the antecedent field of hydra.query.PatternImplication+patternImplicationWithAntecedent :: Typed.TypedTerm Query.PatternImplication -> Typed.TypedTerm Query.Pattern -> Typed.TypedTerm Query.PatternImplication+patternImplicationWithAntecedent original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "antecedent"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "consequent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"),+              Core.projectionFieldName = (Core.Name "consequent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the consequent field of hydra.query.PatternImplication+patternImplicationWithConsequent :: Typed.TypedTerm Query.PatternImplication -> Typed.TypedTerm Query.Pattern -> Typed.TypedTerm Query.PatternImplication+patternImplicationWithConsequent original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "antecedent"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"),+              Core.projectionFieldName = (Core.Name "antecedent")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "consequent"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the negation variant of hydra.query.Pattern+patternNegation :: Typed.TypedTerm Query.Pattern -> Typed.TypedTerm Query.Pattern+patternNegation x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "negation"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the triple variant of hydra.query.Pattern+patternTriple :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Pattern+patternTriple x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "triple"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.query.Query+query :: Typed.TypedTerm [Query.Variable] -> Typed.TypedTerm [Query.Pattern] -> Typed.TypedTerm Query.Query+query variables patterns =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Query"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Typed.unTypedTerm variables)},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Typed.unTypedTerm patterns)}]}))+-- | DSL accessor for the patterns field of hydra.query.Query+queryPatterns :: Typed.TypedTerm Query.Query -> Typed.TypedTerm [Query.Pattern]+queryPatterns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.Query"),+        Core.projectionFieldName = (Core.Name "patterns")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the variables field of hydra.query.Query+queryVariables :: Typed.TypedTerm Query.Query -> Typed.TypedTerm [Query.Variable]+queryVariables x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.Query"),+        Core.projectionFieldName = (Core.Name "variables")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the patterns field of hydra.query.Query+queryWithPatterns :: Typed.TypedTerm Query.Query -> Typed.TypedTerm [Query.Pattern] -> Typed.TypedTerm Query.Query+queryWithPatterns original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Query"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Query"),+              Core.projectionFieldName = (Core.Name "variables")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the variables field of hydra.query.Query+queryWithVariables :: Typed.TypedTerm Query.Query -> Typed.TypedTerm [Query.Variable] -> Typed.TypedTerm Query.Query+queryWithVariables original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Query"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Query"),+              Core.projectionFieldName = (Core.Name "patterns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.query.Range+range :: Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Query.Range+range min max =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Range"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "min"),+          Core.fieldTerm = (Typed.unTypedTerm min)},+        Core.Field {+          Core.fieldName = (Core.Name "max"),+          Core.fieldTerm = (Typed.unTypedTerm max)}]}))+-- | DSL accessor for the max field of hydra.query.Range+rangeMax :: Typed.TypedTerm Query.Range -> Typed.TypedTerm Int+rangeMax x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.Range"),+        Core.projectionFieldName = (Core.Name "max")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the min field of hydra.query.Range+rangeMin :: Typed.TypedTerm Query.Range -> Typed.TypedTerm Int+rangeMin x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.Range"),+        Core.projectionFieldName = (Core.Name "min")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the max field of hydra.query.Range+rangeWithMax :: Typed.TypedTerm Query.Range -> Typed.TypedTerm Int -> Typed.TypedTerm Query.Range+rangeWithMax original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Range"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "min"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Range"),+              Core.projectionFieldName = (Core.Name "min")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "max"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the min field of hydra.query.Range+rangeWithMin :: Typed.TypedTerm Query.Range -> Typed.TypedTerm Int -> Typed.TypedTerm Query.Range+rangeWithMin original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Range"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "min"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "max"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.Range"),+              Core.projectionFieldName = (Core.Name "max")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL injection for the atLeast variant of hydra.query.RegexQuantifier+regexQuantifierAtLeast :: Typed.TypedTerm Int -> Typed.TypedTerm Query.RegexQuantifier+regexQuantifierAtLeast x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "atLeast"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the exactly variant of hydra.query.RegexQuantifier+regexQuantifierExactly :: Typed.TypedTerm Int -> Typed.TypedTerm Query.RegexQuantifier+regexQuantifierExactly x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "exactly"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the one variant of hydra.query.RegexQuantifier+regexQuantifierOne :: Typed.TypedTerm Query.RegexQuantifier+regexQuantifierOne =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "one"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the oneOrMore variant of hydra.query.RegexQuantifier+regexQuantifierOneOrMore :: Typed.TypedTerm Query.RegexQuantifier+regexQuantifierOneOrMore =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "oneOrMore"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the range variant of hydra.query.RegexQuantifier+regexQuantifierRange :: Typed.TypedTerm Query.Range -> Typed.TypedTerm Query.RegexQuantifier+regexQuantifierRange x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "range"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the zeroOrMore variant of hydra.query.RegexQuantifier+regexQuantifierZeroOrMore :: Typed.TypedTerm Query.RegexQuantifier+regexQuantifierZeroOrMore =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "zeroOrMore"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the zeroOrOne variant of hydra.query.RegexQuantifier+regexQuantifierZeroOrOne :: Typed.TypedTerm Query.RegexQuantifier+regexQuantifierZeroOrOne =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "zeroOrOne"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for hydra.query.RegexSequence+regexSequence :: Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.RegexQuantifier -> Typed.TypedTerm Query.RegexSequence+regexSequence path quantifier =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm path)},+        Core.Field {+          Core.fieldName = (Core.Name "quantifier"),+          Core.fieldTerm = (Typed.unTypedTerm quantifier)}]}))+-- | DSL accessor for the path field of hydra.query.RegexSequence+regexSequencePath :: Typed.TypedTerm Query.RegexSequence -> Typed.TypedTerm Query.Path+regexSequencePath x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"),+        Core.projectionFieldName = (Core.Name "path")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the quantifier field of hydra.query.RegexSequence+regexSequenceQuantifier :: Typed.TypedTerm Query.RegexSequence -> Typed.TypedTerm Query.RegexQuantifier+regexSequenceQuantifier x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"),+        Core.projectionFieldName = (Core.Name "quantifier")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the path field of hydra.query.RegexSequence+regexSequenceWithPath :: Typed.TypedTerm Query.RegexSequence -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.RegexSequence+regexSequenceWithPath original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "quantifier"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"),+              Core.projectionFieldName = (Core.Name "quantifier")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the quantifier field of hydra.query.RegexSequence+regexSequenceWithQuantifier :: Typed.TypedTerm Query.RegexSequence -> Typed.TypedTerm Query.RegexQuantifier -> Typed.TypedTerm Query.RegexSequence+regexSequenceWithQuantifier original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"),+              Core.projectionFieldName = (Core.Name "path")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "quantifier"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the compare variant of hydra.query.Step+stepCompare :: Typed.TypedTerm Query.ComparisonConstraint -> Typed.TypedTerm Query.Step+stepCompare x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Step"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "compare"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the edge variant of hydra.query.Step+stepEdge :: Typed.TypedTerm Query.Edge -> Typed.TypedTerm Query.Step+stepEdge x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Step"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "edge"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the project variant of hydra.query.Step+stepProject :: Typed.TypedTerm Core.Projection -> Typed.TypedTerm Query.Step+stepProject x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.query.Step"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "project"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.query.TriplePattern+triplePattern :: Typed.TypedTerm Query.Node -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.Node -> Typed.TypedTerm Query.TriplePattern+triplePattern subject predicate object =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm subject)},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Typed.unTypedTerm predicate)},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Typed.unTypedTerm object)}]}))+-- | DSL accessor for the object field of hydra.query.TriplePattern+triplePatternObject :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Node+triplePatternObject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+        Core.projectionFieldName = (Core.Name "object")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the predicate field of hydra.query.TriplePattern+triplePatternPredicate :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Path+triplePatternPredicate x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+        Core.projectionFieldName = (Core.Name "predicate")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the subject field of hydra.query.TriplePattern+triplePatternSubject :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Node+triplePatternSubject x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+        Core.projectionFieldName = (Core.Name "subject")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the object field of hydra.query.TriplePattern+triplePatternWithObject :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Node -> Typed.TypedTerm Query.TriplePattern+triplePatternWithObject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+              Core.projectionFieldName = (Core.Name "predicate")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the predicate field of hydra.query.TriplePattern+triplePatternWithPredicate :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Path -> Typed.TypedTerm Query.TriplePattern+triplePatternWithPredicate original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+              Core.projectionFieldName = (Core.Name "subject")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+              Core.projectionFieldName = (Core.Name "object")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the subject field of hydra.query.TriplePattern+triplePatternWithSubject :: Typed.TypedTerm Query.TriplePattern -> Typed.TypedTerm Query.Node -> Typed.TypedTerm Query.TriplePattern+triplePatternWithSubject original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+              Core.projectionFieldName = (Core.Name "predicate")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+              Core.projectionFieldName = (Core.Name "object")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL accessor for the body of hydra.query.Variable+unVariable :: Typed.TypedTerm Query.Variable -> Typed.TypedTerm String+unVariable x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.query.Variable")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.query.Variable wrapper+variable :: Typed.TypedTerm String -> Typed.TypedTerm Query.Variable+variable x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.query.Variable"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Relational.hs view
@@ -0,0 +1,374 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.relational++module Hydra.Dsl.Relational where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Relational as Relational+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | DSL constructor for the hydra.relational.ColumnName wrapper+columnName :: Typed.TypedTerm String -> Typed.TypedTerm Relational.ColumnName+columnName x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.relational.ColumnSchema+columnSchema :: Typed.TypedTerm Relational.ColumnName -> Typed.TypedTerm t -> Typed.TypedTerm (Relational.ColumnSchema t)+columnSchema name domain =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm domain)}]}))+-- | DSL accessor for the domain field of hydra.relational.ColumnSchema+columnSchemaDomain :: Typed.TypedTerm (Relational.ColumnSchema t) -> Typed.TypedTerm t+columnSchemaDomain x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"),+        Core.projectionFieldName = (Core.Name "domain")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.relational.ColumnSchema+columnSchemaName :: Typed.TypedTerm (Relational.ColumnSchema t) -> Typed.TypedTerm Relational.ColumnName+columnSchemaName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the domain field of hydra.relational.ColumnSchema+columnSchemaWithDomain :: Typed.TypedTerm (Relational.ColumnSchema t) -> Typed.TypedTerm t -> Typed.TypedTerm (Relational.ColumnSchema t)+columnSchemaWithDomain original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.relational.ColumnSchema+columnSchemaWithName :: Typed.TypedTerm (Relational.ColumnSchema t) -> Typed.TypedTerm Relational.ColumnName -> Typed.TypedTerm (Relational.ColumnSchema t)+columnSchemaWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"),+              Core.projectionFieldName = (Core.Name "domain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.relational.ForeignKey+foreignKey :: Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm (M.Map Relational.ColumnName Relational.ColumnName) -> Typed.TypedTerm Relational.ForeignKey+foreignKey foreignRelation keys =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "foreignRelation"),+          Core.fieldTerm = (Typed.unTypedTerm foreignRelation)},+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = (Typed.unTypedTerm keys)}]}))+-- | DSL accessor for the foreignRelation field of hydra.relational.ForeignKey+foreignKeyForeignRelation :: Typed.TypedTerm Relational.ForeignKey -> Typed.TypedTerm Relational.RelationName+foreignKeyForeignRelation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"),+        Core.projectionFieldName = (Core.Name "foreignRelation")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the keys field of hydra.relational.ForeignKey+foreignKeyKeys :: Typed.TypedTerm Relational.ForeignKey -> Typed.TypedTerm (M.Map Relational.ColumnName Relational.ColumnName)+foreignKeyKeys x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"),+        Core.projectionFieldName = (Core.Name "keys")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the foreignRelation field of hydra.relational.ForeignKey+foreignKeyWithForeignRelation :: Typed.TypedTerm Relational.ForeignKey -> Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm Relational.ForeignKey+foreignKeyWithForeignRelation original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "foreignRelation"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"),+              Core.projectionFieldName = (Core.Name "keys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the keys field of hydra.relational.ForeignKey+foreignKeyWithKeys :: Typed.TypedTerm Relational.ForeignKey -> Typed.TypedTerm (M.Map Relational.ColumnName Relational.ColumnName) -> Typed.TypedTerm Relational.ForeignKey+foreignKeyWithKeys original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "foreignRelation"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"),+              Core.projectionFieldName = (Core.Name "foreignRelation")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for the hydra.relational.PrimaryKey wrapper+primaryKey :: Typed.TypedTerm [Relational.ColumnName] -> Typed.TypedTerm Relational.PrimaryKey+primaryKey x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.relational.Relation wrapper+relation :: Typed.TypedTerm [Relational.Row v] -> Typed.TypedTerm (Relational.Relation v)+relation x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relation"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.relational.RelationName wrapper+relationName :: Typed.TypedTerm String -> Typed.TypedTerm Relational.RelationName+relationName x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.relational.RelationSchema+relationSchema :: Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm [Relational.ColumnSchema t] -> Typed.TypedTerm [Relational.PrimaryKey] -> Typed.TypedTerm [Relational.ForeignKey] -> Typed.TypedTerm (Relational.RelationSchema t)+relationSchema name columns primaryKeys foreignKeys =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Typed.unTypedTerm columns)},+        Core.Field {+          Core.fieldName = (Core.Name "primaryKeys"),+          Core.fieldTerm = (Typed.unTypedTerm primaryKeys)},+        Core.Field {+          Core.fieldName = (Core.Name "foreignKeys"),+          Core.fieldTerm = (Typed.unTypedTerm foreignKeys)}]}))+-- | DSL accessor for the columns field of hydra.relational.RelationSchema+relationSchemaColumns :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm [Relational.ColumnSchema t]+relationSchemaColumns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+        Core.projectionFieldName = (Core.Name "columns")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the foreignKeys field of hydra.relational.RelationSchema+relationSchemaForeignKeys :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm [Relational.ForeignKey]+relationSchemaForeignKeys x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+        Core.projectionFieldName = (Core.Name "foreignKeys")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.relational.RelationSchema+relationSchemaName :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm Relational.RelationName+relationSchemaName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the primaryKeys field of hydra.relational.RelationSchema+relationSchemaPrimaryKeys :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm [Relational.PrimaryKey]+relationSchemaPrimaryKeys x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+        Core.projectionFieldName = (Core.Name "primaryKeys")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the columns field of hydra.relational.RelationSchema+relationSchemaWithColumns :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm [Relational.ColumnSchema t] -> Typed.TypedTerm (Relational.RelationSchema t)+relationSchemaWithColumns original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "primaryKeys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "primaryKeys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "foreignKeys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "foreignKeys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the foreignKeys field of hydra.relational.RelationSchema+relationSchemaWithForeignKeys :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm [Relational.ForeignKey] -> Typed.TypedTerm (Relational.RelationSchema t)+relationSchemaWithForeignKeys original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "columns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primaryKeys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "primaryKeys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "foreignKeys"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.relational.RelationSchema+relationSchemaWithName :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm (Relational.RelationSchema t)+relationSchemaWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "columns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primaryKeys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "primaryKeys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "foreignKeys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "foreignKeys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the primaryKeys field of hydra.relational.RelationSchema+relationSchemaWithPrimaryKeys :: Typed.TypedTerm (Relational.RelationSchema t) -> Typed.TypedTerm [Relational.PrimaryKey] -> Typed.TypedTerm (Relational.RelationSchema t)+relationSchemaWithPrimaryKeys original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "columns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "primaryKeys"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "foreignKeys"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+              Core.projectionFieldName = (Core.Name "foreignKeys")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.relational.Relationship wrapper+relationship :: Typed.TypedTerm (S.Set (M.Map Relational.ColumnName v)) -> Typed.TypedTerm (Relational.Relationship v)+relationship x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.relational.Row wrapper+row :: Typed.TypedTerm [v] -> Typed.TypedTerm (Relational.Row v)+row x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.relational.ColumnName+unColumnName :: Typed.TypedTerm Relational.ColumnName -> Typed.TypedTerm String+unColumnName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.ColumnName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.relational.PrimaryKey+unPrimaryKey :: Typed.TypedTerm Relational.PrimaryKey -> Typed.TypedTerm [Relational.ColumnName]+unPrimaryKey x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.PrimaryKey")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.relational.Relation+unRelation :: Typed.TypedTerm (Relational.Relation v) -> Typed.TypedTerm [Relational.Row v]+unRelation x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Relation")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.relational.RelationName+unRelationName :: Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm String+unRelationName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.RelationName")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.relational.Relationship+unRelationship :: Typed.TypedTerm (Relational.Relationship v) -> Typed.TypedTerm (S.Set (M.Map Relational.ColumnName v))+unRelationship x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Relationship")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.relational.Row+unRow :: Typed.TypedTerm (Relational.Row v) -> Typed.TypedTerm [v]+unRow x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Row")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Tabular.hs view
@@ -0,0 +1,216 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.tabular++module Hydra.Dsl.Tabular where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Relational as DslRelational+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL constructor for hydra.tabular.ColumnType+columnType :: Typed.TypedTerm Relational.ColumnName -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Tabular.ColumnType+columnType name type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))+-- | DSL accessor for the name field of hydra.tabular.ColumnType+columnTypeName :: Typed.TypedTerm Tabular.ColumnType -> Typed.TypedTerm Relational.ColumnName+columnTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.tabular.ColumnType+columnTypeType :: Typed.TypedTerm Tabular.ColumnType -> Typed.TypedTerm Core.Type+columnTypeType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the name field of hydra.tabular.ColumnType+columnTypeWithName :: Typed.TypedTerm Tabular.ColumnType -> Typed.TypedTerm Relational.ColumnName -> Typed.TypedTerm Tabular.ColumnType+columnTypeWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.tabular.ColumnType+columnTypeWithType :: Typed.TypedTerm Tabular.ColumnType -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Tabular.ColumnType+columnTypeWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for the hydra.tabular.DataRow wrapper+dataRow :: Typed.TypedTerm [Maybe v] -> Typed.TypedTerm (Tabular.DataRow v)+dataRow x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for the hydra.tabular.HeaderRow wrapper+headerRow :: Typed.TypedTerm [String] -> Typed.TypedTerm Tabular.HeaderRow+headerRow x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.tabular.Table+table :: Typed.TypedTerm (Maybe Tabular.HeaderRow) -> Typed.TypedTerm [Tabular.DataRow v] -> Typed.TypedTerm (Tabular.Table v)+table header data_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.Table"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "header"),+          Core.fieldTerm = (Typed.unTypedTerm header)},+        Core.Field {+          Core.fieldName = (Core.Name "data"),+          Core.fieldTerm = (Typed.unTypedTerm data_)}]}))+-- | DSL accessor for the data field of hydra.tabular.Table+tableData :: Typed.TypedTerm (Tabular.Table v) -> Typed.TypedTerm [Tabular.DataRow v]+tableData x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.tabular.Table"),+        Core.projectionFieldName = (Core.Name "data")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the header field of hydra.tabular.Table+tableHeader :: Typed.TypedTerm (Tabular.Table v) -> Typed.TypedTerm (Maybe Tabular.HeaderRow)+tableHeader x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.tabular.Table"),+        Core.projectionFieldName = (Core.Name "header")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.tabular.TableType+tableType :: Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm [Tabular.ColumnType] -> Typed.TypedTerm Tabular.TableType+tableType name columns =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.TableType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Typed.unTypedTerm columns)}]}))+-- | DSL accessor for the columns field of hydra.tabular.TableType+tableTypeColumns :: Typed.TypedTerm Tabular.TableType -> Typed.TypedTerm [Tabular.ColumnType]+tableTypeColumns x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"),+        Core.projectionFieldName = (Core.Name "columns")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.tabular.TableType+tableTypeName :: Typed.TypedTerm Tabular.TableType -> Typed.TypedTerm Relational.RelationName+tableTypeName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the columns field of hydra.tabular.TableType+tableTypeWithColumns :: Typed.TypedTerm Tabular.TableType -> Typed.TypedTerm [Tabular.ColumnType] -> Typed.TypedTerm Tabular.TableType+tableTypeWithColumns original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.TableType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.tabular.TableType+tableTypeWithName :: Typed.TypedTerm Tabular.TableType -> Typed.TypedTerm Relational.RelationName -> Typed.TypedTerm Tabular.TableType+tableTypeWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.TableType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"),+              Core.projectionFieldName = (Core.Name "columns")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the data field of hydra.tabular.Table+tableWithData :: Typed.TypedTerm (Tabular.Table v) -> Typed.TypedTerm [Tabular.DataRow v] -> Typed.TypedTerm (Tabular.Table v)+tableWithData original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.Table"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "header"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.tabular.Table"),+              Core.projectionFieldName = (Core.Name "header")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "data"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the header field of hydra.tabular.Table+tableWithHeader :: Typed.TypedTerm (Tabular.Table v) -> Typed.TypedTerm (Maybe Tabular.HeaderRow) -> Typed.TypedTerm (Tabular.Table v)+tableWithHeader original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.Table"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "header"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "data"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.tabular.Table"),+              Core.projectionFieldName = (Core.Name "data")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL accessor for the body of hydra.tabular.DataRow+unDataRow :: Typed.TypedTerm (Tabular.DataRow v) -> Typed.TypedTerm [Maybe v]+unDataRow x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.tabular.DataRow")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.tabular.HeaderRow+unHeaderRow :: Typed.TypedTerm Tabular.HeaderRow -> Typed.TypedTerm [String]+unHeaderRow x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.tabular.HeaderRow")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Terms.hs view
@@ -0,0 +1,386 @@+-- | A domain-specific language for constructing Hydra terms in Haskell.+module Hydra.Dsl.Terms where++import Hydra.Constants+import Hydra.Core+import Hydra.Graph+import Hydra.Util+import Hydra.Dsl.Meta.Common+import qualified Hydra.Dsl.Literals as Literals++import Prelude hiding (map, product)+import Data.Int+import qualified Data.ByteString as B+import qualified Data.Char as C+import qualified Data.List as L+import qualified Data.Map as M+import qualified Data.Scientific as Sci+import qualified Data.Set as S+++-- | Function composition operator: f <.> g creates a function that applies g then f+-- Example: var "stringLength" <.> var "toString"+(<.>) :: Term -> Term -> Term+f <.> g = compose f g++-- | Term application operator: function @@ argument+-- Example: var "add" @@ int32 1+(@@) :: Term -> Term -> Term+fun @@ arg = apply fun arg++-- | Field definition operator: name>: value+-- Example: "name">: string "John"+infixr 0 >:+(>:) :: String -> Term -> Field+name>: term = field name term++-- | Attach an annotation map to a term, wrapping the map as a TermMap per+-- Hydra's convention (#386 — annotation is now a Term, not a Map<Name, Term>).+-- Each Name key is lifted to a TermVariable.+-- Example: annot (M.fromList [(Name "comment", string "A User ID")]) (var "userId")+annot :: M.Map Name Term -> Term -> Term+annot ann term = TermAnnotated $ AnnotatedTerm term (annotationMapAsTerm ann)++-- | Attach an annotation map to a term (alternative argument order).+-- Example: annotated (var "userId") (M.fromList [(Name "comment", string "A User ID")])+annotated :: Term -> M.Map Name Term -> Term+annotated term ann = TermAnnotated $ AnnotatedTerm term (annotationMapAsTerm ann)++-- | Wrap a Map<Name, Term> as a TermMap annotation. Each Name key becomes a+-- TermVariable key. The canonical encoding for Hydra's annotation map+-- convention (#386).+annotationMapAsTerm :: M.Map Name Term -> Term+annotationMapAsTerm = TermMap . M.mapKeys TermVariable++-- | Apply a function term to an argument+-- Example: apply (var "capitalize") (string "arthur")+apply :: Term -> Term -> Term+apply fun arg = TermApplication $ Application fun arg++-- | Create a bigint literal+-- Example: bigint 9223372036854775808+bigint :: Integer -> Term+bigint = literal . Literals.bigint++-- | Create a binary data literal from a ByteString.+-- Example: binary (B.pack [0x48, 0x65, 0x00, 0xff, 0x20, 0x7a, 0x1b, 0x80])+binary :: B.ByteString -> Term+binary = literal . Literals.binary++-- | Create a boolean literal+-- Example: boolean True+boolean :: Bool -> Term+boolean = literal . Literals.boolean++char :: Char -> Term+char = int32 . C.ord++comparison :: Comparison -> Term+comparison t = case t of+  ComparisonEqualTo -> injectUnit _Comparison _Comparison_equalTo+  ComparisonLessThan -> injectUnit _Comparison _Comparison_lessThan+  ComparisonGreaterThan -> injectUnit _Comparison _Comparison_greaterThan++-- | Compose two functions (apply g then f) to create a new function+-- Example: compose (var "stringLength") (var "toString")+-- This creates a function equivalent to \x -> stringLength(toString(x))+-- Function composition applies right-to-left: (f ∘ g)(x) = f(g(x))+compose :: Term -> Term -> Term+compose f g = lambda "arg_" $ apply f (apply g $ var "arg_")++-- | Create a constant function that always returns the same value+-- Example: constant true+constant :: Term -> Term+constant = lambda ignoredVariable++-- | Create an arbitrary-precision decimal literal.+-- Example: decimal (Sci.scientific 314159265359 (-11))+decimal :: Sci.Scientific -> Term+decimal = literal . Literals.decimal++-- | Boolean false literal+false :: Term+false = boolean False++-- | Create a field with the given name and value+-- Example: field "age" (int32 30)+field :: String -> Term -> Field+field n = Field (Name n)++-- | First element projection function for pairs+first :: Term+first = primitive $ Name "hydra.lib.pairs.first"++-- | Create a floating-point literal with specified precision+-- Example: float (FloatValueFloat32 3.14)+float :: FloatValue -> Term+float = literal . Literals.float++-- | Create a float32 literal+-- Example: float32 3.14+float32 :: Float -> Term+float32 = literal . Literals.float32++-- | Create a float64 literal+-- Example: float64 3.14159265359+float64 :: Double -> Term+float64 = literal . Literals.float64++-- | Identity function+identity :: Term+identity = lambda "x_" $ var "x_"++-- | Create a union value by injecting a value into a specific variant+-- Example: inject (Name "Result") (Name "success") (int32 42)+-- This creates a "Result" union with the "success" variant containing value 42+-- Use this to construct values of union types at runtime+inject :: Name -> Name -> Term -> Term+inject tname fname term = TermInject $ Injection tname $ Field fname term++-- | Create a unit variant of a union (convenience function)+-- Example: injectUnit (Name "Result") (Name "success")+-- Equivalent to inject but automatically uses unit as the value+injectUnit :: Name -> Name -> Term+injectUnit tname fname = inject tname fname unit++-- | Create an int16 literal+-- Example: int16 32767+int16 :: Int16 -> Term+int16 = literal . Literals.int16++-- | Create an int32 literal+-- Example: int32 42+int32 :: Int -> Term+int32 = literal . Literals.int32++-- | Create an int64 literal+-- Example: int64 9223372036854775807+int64 :: Int64 -> Term+int64 = literal . Literals.int64++-- | Create an int8 literal+-- Example: int8 127+int8 :: Int8 -> Term+int8 = literal . Literals.int8++-- | Create an integer literal with specified bit width+-- Example: integer (IntegerValueInt32 42)+integer :: IntegerValue -> Term+integer = literal . Literals.integer++-- | Create a 'Just' optional value+-- Example: just (string "found")+just :: Term -> Term+just = optional . Just++-- | Create a lambda function with one parameter+-- Example: lambda "x" (var "x" @@ int32 1)+lambda :: String -> Term -> Term+lambda param body = TermLambda $ Lambda (Name param) Nothing body++-- | Create a lambda function with a given domain+-- Example: lambdaTyped "x" Types.int32 (list [var "x"])+lambdaTyped :: String -> Type -> Term -> Term+lambdaTyped param dom body = TermLambda $ Lambda (Name param) (Just dom) body++-- | Create a multi-parameter lambda function (curried)+-- Example: lambdas ["x", "y"] (var "add" @@ var "x" @@ var "y")+-- This creates the function \x.\y.add x y+lambdas :: [String] -> Term -> Term+lambdas params body = case params of+  [] -> body+  (h:r) -> lambda h $ lambdas r body++-- | Create a 'Left' either value+-- Example: left (string "error")+left :: Term -> Term+left term = TermEither (Left term)++-- | Create a let term with any number of bindings+-- Example: lets ["x">: int32 1, "y">: int32 2] (pair (var "x") (var "y"))+lets :: [Field] -> Term -> Term+lets bindings env = TermLet $ Let (toBinding <$> bindings) env+  where+    toBinding (Field name value) = Binding name value Nothing++letsTyped :: [(String, Term, TypeScheme)] -> Term -> Term+letsTyped bindings env = TermLet $ Let (toBinding <$> bindings) env+  where+    toBinding (name, value, ts) = Binding (Name name) value (Just ts)++-- | Create a list of terms+-- Example: list [int32 1, int32 2, int32 3]+list :: [Term] -> Term+list = TermList++-- | Create a term from a literal value+-- Example: literal (LiteralString "hello")+literal :: Literal -> Term+literal = TermLiteral++-- | Create a map/dictionary term+-- Example: map (M.fromList [(string "January", int32 31), (string "February", int32 28)])+map :: M.Map Term Term -> Term+map = TermMap++-- | Create a pattern match on a union type+-- Example: match (Name "Result") (Just (string "unknown"))+--               ["success">: lambda "s" (var "processSuccess" @@ var "s"),+--                "error">: lambda "e" (var "handleError" @@ var "e")]+-- This allows handling different cases of a union type with specific logic for each variant.+-- The optional second parameter provides a default case for any unmatched variants.+match :: Name -> Maybe Term -> [Field] -> Term+match tname def fields = TermCases $ CaseStatement tname def (fieldToCaseAlternative <$> fields)+  where+    -- The DSL builds case alternatives via the same >>: operator used for record/union+    -- fields, so call sites still pass [Field]; convert each to a CaseAlternative here.+    fieldToCaseAlternative (Field fname fterm) = CaseAlternative fname fterm++-- | Create a 'Nothing' optional value+nothing :: Term+nothing = optional Nothing++-- | Create a Maybe (nullable) term+-- Example: optional (Just (string "found"))+optional :: Maybe Term -> Term+optional = TermOptional++-- | Create a pair+-- Example: pair (string "name") (int32 42)+pair :: Term -> Term -> Term+pair a b = TermPair (a, b)++-- | Create a reference to a primitive function.+-- Uses TermVariable; the name resolves via graphPrimitives fallthrough.+-- Example: primitive (Name "hydra.lib.strings.length")+primitive :: Name -> Term+primitive = TermVariable++-- | Create a field projection function+-- Example: project (Name "Person") (Name "firstName")+project :: Name -> Name -> Term+project tname fname = TermProject $ Projection tname fname++-- | Create a record with named fields of the specified type+-- Example: record (Name "Person") [+--            "name">: string "John",+--            "age">: int32 30,+--            "email">: string "john@example.com"]+-- Records are products of named fields with values that can be accessed by field name+record :: Name -> [Field] -> Term+record tname fields = TermRecord $ Record tname fields++-- | Create a 'Right' either value+-- Example: right (int32 42)+right :: Term -> Term+right term = TermEither (Right term)++-- | Second element projection function for pairs+second :: Term+second = primitive $ Name "hydra.lib.pairs.second"++-- | Create a set of terms+-- Example: set (S.fromList [string "a", string "b", string "c"])+set :: S.Set Term -> Term+set = TermSet++-- | Create a string literal+-- Example: string "hello world"+string :: String -> Term+string = TermLiteral . LiteralString++triple :: Term -> Term -> Term -> Term+triple a b c = pair a (pair b c)++-- | Boolean true literal+true :: Term+true = boolean True++-- | Create a tuple using nested pairs (deprecated: use pair directly)+-- Example: tuple2 a b creates pair a b+-- Example: tuple3 a b c creates pair a (pair b c)+tuple :: [Term] -> Term+tuple [] = unit+tuple [a] = a+tuple [a, b] = pair a b+tuple (a:rest) = pair a (tuple rest)++-- | Create a 2-tuple (same as pair)+tuple2 :: Term -> Term -> Term+tuple2 = pair++tuple3 :: Term -> Term -> Term -> Term+tuple3 a b c = pair a (pair b c)++tuple4 :: Term -> Term -> Term -> Term -> Term+tuple4 a b c d = pair a (pair b (pair c d))++tuple5 :: Term -> Term -> Term -> Term -> Term -> Term+tuple5 a b c d e = pair a (pair b (pair c (pair d e)))++tyapp :: Term -> Type -> Term+tyapp term typ = TermTypeApplication $ TypeApplicationTerm term typ++tyapps = typeApplication++tylam :: String -> Term -> Term+tylam var body = TermTypeLambda $ TypeLambda (Name var) body++tylams :: [String] -> Term -> Term+tylams vars body = L.foldl (\b v -> TermTypeLambda $ TypeLambda (Name v) b) body $ L.reverse vars++-- | Apply type arguments to a polymorphic term+-- Example: typeApplication (var "map") [Types.int32, Types.string]+-- This instantiates a polymorphic function with concrete types.+-- For instance, if 'map' has type 'forall a b. (a -> b) -> list a -> list b',+-- the example would instantiate it to '(int32 -> string) -> list int32 -> list string'.+typeApplication :: Term -> [Type] -> Term+typeApplication term types = L.foldl (\t ty -> TermTypeApplication $ TypeApplicationTerm t ty) term types++-- | Create a type abstraction (universal quantification)+-- Example: typeLambda [Name "a", Name "b"] (lambdaTyped "f" (Types.function (Types.var "a") (Types.var "b"))+--                                               (lambdaTyped "x" (Types.var "a") (var "f" @@ var "x")))+-- This creates a polymorphic term with type variables.+-- The example creates a higher-order function with type 'forall a b. (a -> b) -> a -> b',+-- which is the polymorphic apply function that works for any types a and b.+typeLambda :: [Name] -> Term -> Term+typeLambda vars body = L.foldl (\b v -> TermTypeLambda $ TypeLambda v b) body vars++-- | Create a uint16 literal+-- Example: uint16 65535+uint16 :: Int -> Term+uint16 = literal . Literals.uint16++-- | Create a uint32 literal+-- Example: uint32 4294967295+uint32 :: Int64 -> Term+uint32 = literal . Literals.uint32++-- | Create a uint64 literal+-- Example: uint64 18446744073709551615+uint64 :: Integer -> Term+uint64 = literal . Literals.uint64++-- | Create a uint8 literal+-- Example: uint8 255+uint8 :: Int16 -> Term+uint8 = literal . Literals.uint8++-- | Unit value (empty record)+unit :: Term+unit = TermUnit++-- | Create an unwrap function for a wrapped type+-- Example: unwrap (Name "Email")+unwrap :: Name -> Term+unwrap = TermUnwrap++-- | Create a variable reference+-- Example: var "x"+var :: String -> Term+var = TermVariable . Name++-- | Create a wrapped term+-- Example: wrap (Name "Email") (string "user@example.com")+wrap :: Name -> Term -> Term+wrap name term = TermWrap $ WrappedTerm name term
+ src/main/haskell/Hydra/Dsl/Testing.hs view
@@ -0,0 +1,430 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.testing++module Hydra.Dsl.Testing where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Testing as Testing+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL constructor for the hydra.testing.Tag wrapper+tag :: Typed.TypedTerm String -> Typed.TypedTerm Testing.Tag+tag x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.testing.Tag"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL injection for the universal variant of hydra.testing.TestCase+testCaseUniversal :: Typed.TypedTerm Testing.UniversalTestCase -> Typed.TypedTerm Testing.TestCase+testCaseUniversal x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.testing.TestCase"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "universal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.testing.TestCaseWithMetadata+testCaseWithMetadata :: Typed.TypedTerm String -> Typed.TypedTerm Testing.TestCase -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [Testing.Tag] -> Typed.TypedTerm Testing.TestCaseWithMetadata+testCaseWithMetadata name case_ description tags =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "case"),+          Core.fieldTerm = (Typed.unTypedTerm case_)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)},+        Core.Field {+          Core.fieldName = (Core.Name "tags"),+          Core.fieldTerm = (Typed.unTypedTerm tags)}]}))+-- | DSL accessor for the case field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataCase :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm Testing.TestCase+testCaseWithMetadataCase x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+        Core.projectionFieldName = (Core.Name "case")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the description field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataDescription :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm (Maybe String)+testCaseWithMetadataDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataName :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm String+testCaseWithMetadataName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the tags field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataTags :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm [Testing.Tag]+testCaseWithMetadataTags x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+        Core.projectionFieldName = (Core.Name "tags")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the case field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataWithCase :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm Testing.TestCase -> Typed.TypedTerm Testing.TestCaseWithMetadata+testCaseWithMetadataWithCase original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "case"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "tags"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "tags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the description field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataWithDescription :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Testing.TestCaseWithMetadata+testCaseWithMetadataWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "case"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "case")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "tags"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "tags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataWithName :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TestCaseWithMetadata+testCaseWithMetadataWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "case"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "case")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "tags"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "tags")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the tags field of hydra.testing.TestCaseWithMetadata+testCaseWithMetadataWithTags :: Typed.TypedTerm Testing.TestCaseWithMetadata -> Typed.TypedTerm [Testing.Tag] -> Typed.TypedTerm Testing.TestCaseWithMetadata+testCaseWithMetadataWithTags original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "case"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "case")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestCaseWithMetadata"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "tags"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.testing.TestGroup+testGroup :: Typed.TypedTerm String -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm [Testing.TestGroup] -> Typed.TypedTerm [Testing.TestCaseWithMetadata] -> Typed.TypedTerm Testing.TestGroup+testGroup name description subgroups cases =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)},+        Core.Field {+          Core.fieldName = (Core.Name "subgroups"),+          Core.fieldTerm = (Typed.unTypedTerm subgroups)},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Typed.unTypedTerm cases)}]}))+-- | DSL accessor for the cases field of hydra.testing.TestGroup+testGroupCases :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm [Testing.TestCaseWithMetadata]+testGroupCases x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+        Core.projectionFieldName = (Core.Name "cases")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the description field of hydra.testing.TestGroup+testGroupDescription :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm (Maybe String)+testGroupDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.testing.TestGroup+testGroupName :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm String+testGroupName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the subgroups field of hydra.testing.TestGroup+testGroupSubgroups :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm [Testing.TestGroup]+testGroupSubgroups x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+        Core.projectionFieldName = (Core.Name "subgroups")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the cases field of hydra.testing.TestGroup+testGroupWithCases :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm [Testing.TestCaseWithMetadata] -> Typed.TypedTerm Testing.TestGroup+testGroupWithCases original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subgroups"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "subgroups")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the description field of hydra.testing.TestGroup+testGroupWithDescription :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Testing.TestGroup+testGroupWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "subgroups"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "subgroups")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "cases")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the name field of hydra.testing.TestGroup+testGroupWithName :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm String -> Typed.TypedTerm Testing.TestGroup+testGroupWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subgroups"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "subgroups")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "cases")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the subgroups field of hydra.testing.TestGroup+testGroupWithSubgroups :: Typed.TypedTerm Testing.TestGroup -> Typed.TypedTerm [Testing.TestGroup] -> Typed.TypedTerm Testing.TestGroup+testGroupWithSubgroups original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.TestGroup"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subgroups"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.TestGroup"),+              Core.projectionFieldName = (Core.Name "cases")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL accessor for the body of hydra.testing.Tag+unTag :: Typed.TypedTerm Testing.Tag -> Typed.TypedTerm String+unTag x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.testing.Tag")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.testing.UniversalTestCase+universalTestCase :: Typed.TypedTerm (() -> String) -> Typed.TypedTerm (() -> String) -> Typed.TypedTerm Testing.UniversalTestCase+universalTestCase actual expected =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.UniversalTestCase"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "actual"),+          Core.fieldTerm = (Typed.unTypedTerm actual)},+        Core.Field {+          Core.fieldName = (Core.Name "expected"),+          Core.fieldTerm = (Typed.unTypedTerm expected)}]}))+-- | DSL accessor for the actual field of hydra.testing.UniversalTestCase+universalTestCaseActual :: Typed.TypedTerm Testing.UniversalTestCase -> Typed.TypedTerm (() -> String)+universalTestCaseActual x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.UniversalTestCase"),+        Core.projectionFieldName = (Core.Name "actual")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the expected field of hydra.testing.UniversalTestCase+universalTestCaseExpected :: Typed.TypedTerm Testing.UniversalTestCase -> Typed.TypedTerm (() -> String)+universalTestCaseExpected x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.testing.UniversalTestCase"),+        Core.projectionFieldName = (Core.Name "expected")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the actual field of hydra.testing.UniversalTestCase+universalTestCaseWithActual :: Typed.TypedTerm Testing.UniversalTestCase -> Typed.TypedTerm (() -> String) -> Typed.TypedTerm Testing.UniversalTestCase+universalTestCaseWithActual original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.UniversalTestCase"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "actual"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "expected"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.UniversalTestCase"),+              Core.projectionFieldName = (Core.Name "expected")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the expected field of hydra.testing.UniversalTestCase+universalTestCaseWithExpected :: Typed.TypedTerm Testing.UniversalTestCase -> Typed.TypedTerm (() -> String) -> Typed.TypedTerm Testing.UniversalTestCase+universalTestCaseWithExpected original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.testing.UniversalTestCase"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "actual"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.testing.UniversalTestCase"),+              Core.projectionFieldName = (Core.Name "actual")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "expected"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+ src/main/haskell/Hydra/Dsl/Topology.hs view
@@ -0,0 +1,408 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.topology++module Hydra.Dsl.Topology where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | DSL constructor for hydra.topology.OrderingIsomorphism+orderingIsomorphism :: Typed.TypedTerm ([a] -> [a]) -> Typed.TypedTerm ([a] -> [a]) -> Typed.TypedTerm (Topology.OrderingIsomorphism a)+orderingIsomorphism encode decode =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm encode)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm decode)}]}))+-- | DSL accessor for the decode field of hydra.topology.OrderingIsomorphism+orderingIsomorphismDecode :: Typed.TypedTerm (Topology.OrderingIsomorphism a) -> Typed.TypedTerm ([a] -> [a])+orderingIsomorphismDecode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"),+        Core.projectionFieldName = (Core.Name "decode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the encode field of hydra.topology.OrderingIsomorphism+orderingIsomorphismEncode :: Typed.TypedTerm (Topology.OrderingIsomorphism a) -> Typed.TypedTerm ([a] -> [a])+orderingIsomorphismEncode x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"),+        Core.projectionFieldName = (Core.Name "encode")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the decode field of hydra.topology.OrderingIsomorphism+orderingIsomorphismWithDecode :: Typed.TypedTerm (Topology.OrderingIsomorphism a) -> Typed.TypedTerm ([a] -> [a]) -> Typed.TypedTerm (Topology.OrderingIsomorphism a)+orderingIsomorphismWithDecode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"),+              Core.projectionFieldName = (Core.Name "encode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the encode field of hydra.topology.OrderingIsomorphism+orderingIsomorphismWithEncode :: Typed.TypedTerm (Topology.OrderingIsomorphism a) -> Typed.TypedTerm ([a] -> [a]) -> Typed.TypedTerm (Topology.OrderingIsomorphism a)+orderingIsomorphismWithEncode original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.OrderingIsomorphism"),+              Core.projectionFieldName = (Core.Name "decode")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.topology.TarjanState+tarjanState :: Typed.TypedTerm Int -> Typed.TypedTerm (M.Map Topology.Vertex Int) -> Typed.TypedTerm (M.Map Topology.Vertex Int) -> Typed.TypedTerm [Topology.Vertex] -> Typed.TypedTerm (S.Set Topology.Vertex) -> Typed.TypedTerm [[Topology.Vertex]] -> Typed.TypedTerm Topology.TarjanState+tarjanState counter indices lowLinks stack onStack sccs =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = (Typed.unTypedTerm counter)},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = (Typed.unTypedTerm indices)},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = (Typed.unTypedTerm lowLinks)},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = (Typed.unTypedTerm stack)},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = (Typed.unTypedTerm onStack)},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = (Typed.unTypedTerm sccs)}]}))+-- | DSL accessor for the counter field of hydra.topology.TarjanState+tarjanStateCounter :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm Int+tarjanStateCounter x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+        Core.projectionFieldName = (Core.Name "counter")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the indices field of hydra.topology.TarjanState+tarjanStateIndices :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm (M.Map Topology.Vertex Int)+tarjanStateIndices x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+        Core.projectionFieldName = (Core.Name "indices")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the lowLinks field of hydra.topology.TarjanState+tarjanStateLowLinks :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm (M.Map Topology.Vertex Int)+tarjanStateLowLinks x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+        Core.projectionFieldName = (Core.Name "lowLinks")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the onStack field of hydra.topology.TarjanState+tarjanStateOnStack :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm (S.Set Topology.Vertex)+tarjanStateOnStack x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+        Core.projectionFieldName = (Core.Name "onStack")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the sccs field of hydra.topology.TarjanState+tarjanStateSccs :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm [[Topology.Vertex]]+tarjanStateSccs x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+        Core.projectionFieldName = (Core.Name "sccs")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the stack field of hydra.topology.TarjanState+tarjanStateStack :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm [Topology.Vertex]+tarjanStateStack x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+        Core.projectionFieldName = (Core.Name "stack")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the counter field of hydra.topology.TarjanState+tarjanStateWithCounter :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm Int -> Typed.TypedTerm Topology.TarjanState+tarjanStateWithCounter original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "indices")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "lowLinks")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "stack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "onStack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "sccs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the indices field of hydra.topology.TarjanState+tarjanStateWithIndices :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm (M.Map Topology.Vertex Int) -> Typed.TypedTerm Topology.TarjanState+tarjanStateWithIndices original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "counter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "lowLinks")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "stack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "onStack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "sccs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the lowLinks field of hydra.topology.TarjanState+tarjanStateWithLowLinks :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm (M.Map Topology.Vertex Int) -> Typed.TypedTerm Topology.TarjanState+tarjanStateWithLowLinks original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "counter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "indices")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "stack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "onStack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "sccs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the onStack field of hydra.topology.TarjanState+tarjanStateWithOnStack :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm (S.Set Topology.Vertex) -> Typed.TypedTerm Topology.TarjanState+tarjanStateWithOnStack original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "counter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "indices")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "lowLinks")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "stack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "sccs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the sccs field of hydra.topology.TarjanState+tarjanStateWithSccs :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm [[Topology.Vertex]] -> Typed.TypedTerm Topology.TarjanState+tarjanStateWithSccs original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "counter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "indices")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "lowLinks")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "stack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "onStack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the stack field of hydra.topology.TarjanState+tarjanStateWithStack :: Typed.TypedTerm Topology.TarjanState -> Typed.TypedTerm [Topology.Vertex] -> Typed.TypedTerm Topology.TarjanState+tarjanStateWithStack original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "counter")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "indices")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "lowLinks")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "onStack")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+              Core.projectionFieldName = (Core.Name "sccs")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+ src/main/haskell/Hydra/Dsl/Typing.hs view
@@ -0,0 +1,1315 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.typing++module Hydra.Dsl.Typing where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Paths as DslPaths+import qualified Hydra.Paths as Paths+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | DSL constructor for hydra.typing.FunctionStructure+functionStructure :: Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm Core.Term -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm env -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructure typeParams params bindings body domains codomain environment =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm typeParams)},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Typed.unTypedTerm params)},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Typed.unTypedTerm bindings)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm body)},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Typed.unTypedTerm domains)},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Typed.unTypedTerm codomain)},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Typed.unTypedTerm environment)}]}))+-- | DSL accessor for the bindings field of hydra.typing.FunctionStructure+functionStructureBindings :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Binding]+functionStructureBindings x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+        Core.projectionFieldName = (Core.Name "bindings")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body field of hydra.typing.FunctionStructure+functionStructureBody :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm Core.Term+functionStructureBody x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+        Core.projectionFieldName = (Core.Name "body")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the codomain field of hydra.typing.FunctionStructure+functionStructureCodomain :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm (Maybe Core.Type)+functionStructureCodomain x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+        Core.projectionFieldName = (Core.Name "codomain")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the domains field of hydra.typing.FunctionStructure+functionStructureDomains :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Type]+functionStructureDomains x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+        Core.projectionFieldName = (Core.Name "domains")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the environment field of hydra.typing.FunctionStructure+functionStructureEnvironment :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm env+functionStructureEnvironment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+        Core.projectionFieldName = (Core.Name "environment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the params field of hydra.typing.FunctionStructure+functionStructureParams :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Name]+functionStructureParams x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+        Core.projectionFieldName = (Core.Name "params")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeParams field of hydra.typing.FunctionStructure+functionStructureTypeParams :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Name]+functionStructureTypeParams x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+        Core.projectionFieldName = (Core.Name "typeParams")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the bindings field of hydra.typing.FunctionStructure+functionStructureWithBindings :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Binding] -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructureWithBindings original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "domains")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "codomain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "environment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the body field of hydra.typing.FunctionStructure+functionStructureWithBody :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm Core.Term -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructureWithBody original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "bindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "domains")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "codomain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "environment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the codomain field of hydra.typing.FunctionStructure+functionStructureWithCodomain :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm (Maybe Core.Type) -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructureWithCodomain original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "bindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "domains")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "environment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the domains field of hydra.typing.FunctionStructure+functionStructureWithDomains :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Type] -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructureWithDomains original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "bindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "codomain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "environment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the environment field of hydra.typing.FunctionStructure+functionStructureWithEnvironment :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm env -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructureWithEnvironment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "bindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "domains")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "codomain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the params field of hydra.typing.FunctionStructure+functionStructureWithParams :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructureWithParams original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "typeParams")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "bindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "domains")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "codomain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "environment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the typeParams field of hydra.typing.FunctionStructure+functionStructureWithTypeParams :: Typed.TypedTerm (Typing.FunctionStructure env) -> Typed.TypedTerm [Core.Name] -> Typed.TypedTerm (Typing.FunctionStructure env)+functionStructureWithTypeParams original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "params")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "bindings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "body")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "domains")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "codomain")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+              Core.projectionFieldName = (Core.Name "environment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.typing.InferenceContext+inferenceContext :: Typed.TypedTerm Int -> Typed.TypedTerm [Paths.SubtermStep] -> Typed.TypedTerm Typing.InferenceContext+inferenceContext freshTypeVariableCount trace =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "freshTypeVariableCount"),+          Core.fieldTerm = (Typed.unTypedTerm freshTypeVariableCount)},+        Core.Field {+          Core.fieldName = (Core.Name "trace"),+          Core.fieldTerm = (Typed.unTypedTerm trace)}]}))+-- | DSL accessor for the freshTypeVariableCount field of hydra.typing.InferenceContext+inferenceContextFreshTypeVariableCount :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Int+inferenceContextFreshTypeVariableCount x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"),+        Core.projectionFieldName = (Core.Name "freshTypeVariableCount")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the trace field of hydra.typing.InferenceContext+inferenceContextTrace :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm [Paths.SubtermStep]+inferenceContextTrace x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"),+        Core.projectionFieldName = (Core.Name "trace")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the freshTypeVariableCount field of hydra.typing.InferenceContext+inferenceContextWithFreshTypeVariableCount :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Int -> Typed.TypedTerm Typing.InferenceContext+inferenceContextWithFreshTypeVariableCount original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "freshTypeVariableCount"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "trace"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"),+              Core.projectionFieldName = (Core.Name "trace")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the trace field of hydra.typing.InferenceContext+inferenceContextWithTrace :: Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm [Paths.SubtermStep] -> Typed.TypedTerm Typing.InferenceContext+inferenceContextWithTrace original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "freshTypeVariableCount"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"),+              Core.projectionFieldName = (Core.Name "freshTypeVariableCount")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "trace"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.typing.InferenceResult+inferenceResult :: Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Typing.TypeSubst -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints) -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceResult+inferenceResult term type_ subst classConstraints context =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm term)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "subst"),+          Core.fieldTerm = (Typed.unTypedTerm subst)},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Typed.unTypedTerm classConstraints)},+        Core.Field {+          Core.fieldName = (Core.Name "context"),+          Core.fieldTerm = (Typed.unTypedTerm context)}]}))+-- | DSL accessor for the classConstraints field of hydra.typing.InferenceResult+inferenceResultClassConstraints :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints)+inferenceResultClassConstraints x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+        Core.projectionFieldName = (Core.Name "classConstraints")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the context field of hydra.typing.InferenceResult+inferenceResultContext :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Typing.InferenceContext+inferenceResultContext x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+        Core.projectionFieldName = (Core.Name "context")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the subst field of hydra.typing.InferenceResult+inferenceResultSubst :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Typing.TypeSubst+inferenceResultSubst x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+        Core.projectionFieldName = (Core.Name "subst")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the term field of hydra.typing.InferenceResult+inferenceResultTerm :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Core.Term+inferenceResultTerm x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+        Core.projectionFieldName = (Core.Name "term")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.typing.InferenceResult+inferenceResultType :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Core.Type+inferenceResultType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the classConstraints field of hydra.typing.InferenceResult+inferenceResultWithClassConstraints :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm (M.Map Core.Name Core.TypeVariableConstraints) -> Typed.TypedTerm Typing.InferenceResult+inferenceResultWithClassConstraints original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subst"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "subst")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "context"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "context")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the context field of hydra.typing.InferenceResult+inferenceResultWithContext :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Typing.InferenceContext -> Typed.TypedTerm Typing.InferenceResult+inferenceResultWithContext original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subst"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "subst")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "context"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the subst field of hydra.typing.InferenceResult+inferenceResultWithSubst :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Typing.TypeSubst -> Typed.TypedTerm Typing.InferenceResult+inferenceResultWithSubst original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subst"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "context"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "context")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the term field of hydra.typing.InferenceResult+inferenceResultWithTerm :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Typing.InferenceResult+inferenceResultWithTerm original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "subst"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "subst")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "context"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "context")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.typing.InferenceResult+inferenceResultWithType :: Typed.TypedTerm Typing.InferenceResult -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Typing.InferenceResult+inferenceResultWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "term")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "subst"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "subst")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "classConstraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "context"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+              Core.projectionFieldName = (Core.Name "context")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.typing.Parameter+parameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Bool -> Typed.TypedTerm Typing.Parameter+parameter name description type_ isLazy =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)},+        Core.Field {+          Core.fieldName = (Core.Name "isLazy"),+          Core.fieldTerm = (Typed.unTypedTerm isLazy)}]}))+-- | DSL accessor for the description field of hydra.typing.Parameter+parameterDescription :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm (Maybe String)+parameterDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the isLazy field of hydra.typing.Parameter+parameterIsLazy :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm Bool+parameterIsLazy x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+        Core.projectionFieldName = (Core.Name "isLazy")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.typing.Parameter+parameterName :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm Core.Name+parameterName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.typing.Parameter+parameterType :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm Core.Type+parameterType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the description field of hydra.typing.Parameter+parameterWithDescription :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Typing.Parameter+parameterWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isLazy"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "isLazy")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the isLazy field of hydra.typing.Parameter+parameterWithIsLazy :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm Bool -> Typed.TypedTerm Typing.Parameter+parameterWithIsLazy original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isLazy"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.typing.Parameter+parameterWithName :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Typing.Parameter+parameterWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "isLazy"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "isLazy")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.typing.Parameter+parameterWithType :: Typed.TypedTerm Typing.Parameter -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Typing.Parameter+parameterWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "isLazy"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+              Core.projectionFieldName = (Core.Name "isLazy")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.typing.Result+result :: Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Typing.Result+result description type_ =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Result"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm type_)}]}))+-- | DSL accessor for the description field of hydra.typing.Result+resultDescription :: Typed.TypedTerm Typing.Result -> Typed.TypedTerm (Maybe String)+resultDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.Result"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the type field of hydra.typing.Result+resultType :: Typed.TypedTerm Typing.Result -> Typed.TypedTerm Core.Type+resultType x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.Result"),+        Core.projectionFieldName = (Core.Name "type")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the description field of hydra.typing.Result+resultWithDescription :: Typed.TypedTerm Typing.Result -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Typing.Result+resultWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Result"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Result"),+              Core.projectionFieldName = (Core.Name "type")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the type field of hydra.typing.Result+resultWithType :: Typed.TypedTerm Typing.Result -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Typing.Result+resultWithType original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Result"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.Result"),+              Core.projectionFieldName = (Core.Name "description")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.typing.TermSignature+termSignature :: Typed.TypedTerm [Typing.TypeParameter] -> Typed.TypedTerm [Typing.Parameter] -> Typed.TypedTerm Typing.Result -> Typed.TypedTerm Typing.TermSignature+termSignature typeParameters parameters result =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TermSignature"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParameters"),+          Core.fieldTerm = (Typed.unTypedTerm typeParameters)},+        Core.Field {+          Core.fieldName = (Core.Name "parameters"),+          Core.fieldTerm = (Typed.unTypedTerm parameters)},+        Core.Field {+          Core.fieldName = (Core.Name "result"),+          Core.fieldTerm = (Typed.unTypedTerm result)}]}))+-- | DSL accessor for the parameters field of hydra.typing.TermSignature+termSignatureParameters :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm [Typing.Parameter]+termSignatureParameters x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+        Core.projectionFieldName = (Core.Name "parameters")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the result field of hydra.typing.TermSignature+termSignatureResult :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm Typing.Result+termSignatureResult x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+        Core.projectionFieldName = (Core.Name "result")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the typeParameters field of hydra.typing.TermSignature+termSignatureTypeParameters :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm [Typing.TypeParameter]+termSignatureTypeParameters x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+        Core.projectionFieldName = (Core.Name "typeParameters")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the parameters field of hydra.typing.TermSignature+termSignatureWithParameters :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm [Typing.Parameter] -> Typed.TypedTerm Typing.TermSignature+termSignatureWithParameters original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TermSignature"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParameters"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+              Core.projectionFieldName = (Core.Name "typeParameters")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "parameters"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "result"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+              Core.projectionFieldName = (Core.Name "result")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the result field of hydra.typing.TermSignature+termSignatureWithResult :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm Typing.Result -> Typed.TypedTerm Typing.TermSignature+termSignatureWithResult original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TermSignature"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParameters"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+              Core.projectionFieldName = (Core.Name "typeParameters")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "parameters"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+              Core.projectionFieldName = (Core.Name "parameters")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "result"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the typeParameters field of hydra.typing.TermSignature+termSignatureWithTypeParameters :: Typed.TypedTerm Typing.TermSignature -> Typed.TypedTerm [Typing.TypeParameter] -> Typed.TypedTerm Typing.TermSignature+termSignatureWithTypeParameters original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TermSignature"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParameters"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "parameters"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+              Core.projectionFieldName = (Core.Name "parameters")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "result"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+              Core.projectionFieldName = (Core.Name "result")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.typing.TermSubst wrapper+termSubst :: Typed.TypedTerm (M.Map Core.Name Core.Term) -> Typed.TypedTerm Typing.TermSubst+termSubst x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.typing.TypeClass+typeClass :: Typed.TypedTerm String -> Typed.TypedTerm Typing.TypeClass+typeClass description =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeClass"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm description)}]}))+-- | DSL accessor for the description field of hydra.typing.TypeClass+typeClassDescription :: Typed.TypedTerm Typing.TypeClass -> Typed.TypedTerm String+typeClassDescription x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TypeClass"),+        Core.projectionFieldName = (Core.Name "description")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the description field of hydra.typing.TypeClass+typeClassWithDescription :: Typed.TypedTerm Typing.TypeClass -> Typed.TypedTerm String -> Typed.TypedTerm Typing.TypeClass+typeClassWithDescription original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeClass"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL constructor for hydra.typing.TypeConstraint+typeConstraint :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type -> Typed.TypedTerm String -> Typed.TypedTerm Typing.TypeConstraint+typeConstraint left right comment =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm left)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm right)},+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = (Typed.unTypedTerm comment)}]}))+-- | DSL accessor for the comment field of hydra.typing.TypeConstraint+typeConstraintComment :: Typed.TypedTerm Typing.TypeConstraint -> Typed.TypedTerm String+typeConstraintComment x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+        Core.projectionFieldName = (Core.Name "comment")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the left field of hydra.typing.TypeConstraint+typeConstraintLeft :: Typed.TypedTerm Typing.TypeConstraint -> Typed.TypedTerm Core.Type+typeConstraintLeft x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+        Core.projectionFieldName = (Core.Name "left")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the right field of hydra.typing.TypeConstraint+typeConstraintRight :: Typed.TypedTerm Typing.TypeConstraint -> Typed.TypedTerm Core.Type+typeConstraintRight x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+        Core.projectionFieldName = (Core.Name "right")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the comment field of hydra.typing.TypeConstraint+typeConstraintWithComment :: Typed.TypedTerm Typing.TypeConstraint -> Typed.TypedTerm String -> Typed.TypedTerm Typing.TypeConstraint+typeConstraintWithComment original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+              Core.projectionFieldName = (Core.Name "left")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+              Core.projectionFieldName = (Core.Name "right")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the left field of hydra.typing.TypeConstraint+typeConstraintWithLeft :: Typed.TypedTerm Typing.TypeConstraint -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Typing.TypeConstraint+typeConstraintWithLeft original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+              Core.projectionFieldName = (Core.Name "right")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+              Core.projectionFieldName = (Core.Name "comment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the right field of hydra.typing.TypeConstraint+typeConstraintWithRight :: Typed.TypedTerm Typing.TypeConstraint -> Typed.TypedTerm Core.Type -> Typed.TypedTerm Typing.TypeConstraint+typeConstraintWithRight original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+              Core.projectionFieldName = (Core.Name "left")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+              Core.projectionFieldName = (Core.Name "comment")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.typing.TypeParameter+typeParameter :: Typed.TypedTerm Core.Name -> Typed.TypedTerm [Core.TypeClassConstraint] -> Typed.TypedTerm Typing.TypeParameter+typeParameter name constraints =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm name)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm constraints)}]}))+-- | DSL accessor for the constraints field of hydra.typing.TypeParameter+typeParameterConstraints :: Typed.TypedTerm Typing.TypeParameter -> Typed.TypedTerm [Core.TypeClassConstraint]+typeParameterConstraints x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"),+        Core.projectionFieldName = (Core.Name "constraints")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the name field of hydra.typing.TypeParameter+typeParameterName :: Typed.TypedTerm Typing.TypeParameter -> Typed.TypedTerm Core.Name+typeParameterName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"),+        Core.projectionFieldName = (Core.Name "name")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the constraints field of hydra.typing.TypeParameter+typeParameterWithConstraints :: Typed.TypedTerm Typing.TypeParameter -> Typed.TypedTerm [Core.TypeClassConstraint] -> Typed.TypedTerm Typing.TypeParameter+typeParameterWithConstraints original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"),+              Core.projectionFieldName = (Core.Name "name")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the name field of hydra.typing.TypeParameter+typeParameterWithName :: Typed.TypedTerm Typing.TypeParameter -> Typed.TypedTerm Core.Name -> Typed.TypedTerm Typing.TypeParameter+typeParameterWithName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"),+              Core.projectionFieldName = (Core.Name "constraints")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for the hydra.typing.TypeSubst wrapper+typeSubst :: Typed.TypedTerm (M.Map Core.Name Core.Type) -> Typed.TypedTerm Typing.TypeSubst+typeSubst x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.typing.TermSubst+unTermSubst :: Typed.TypedTerm Typing.TermSubst -> Typed.TypedTerm (M.Map Core.Name Core.Term)+unTermSubst x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typing.TermSubst")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the body of hydra.typing.TypeSubst+unTypeSubst :: Typed.TypedTerm Typing.TypeSubst -> Typed.TypedTerm (M.Map Core.Name Core.Type)+unTypeSubst x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typing.TypeSubst")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Util.hs view
@@ -0,0 +1,217 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.util++module Hydra.Dsl.Util where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Packaging as DslPackaging+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typed as Typed+import qualified Hydra.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | DSL injection for the camel variant of hydra.util.CaseConvention+caseConventionCamel :: Typed.TypedTerm Util.CaseConvention+caseConventionCamel =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "camel"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the lowerSnake variant of hydra.util.CaseConvention+caseConventionLowerSnake :: Typed.TypedTerm Util.CaseConvention+caseConventionLowerSnake =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lowerSnake"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the pascal variant of hydra.util.CaseConvention+caseConventionPascal :: Typed.TypedTerm Util.CaseConvention+caseConventionPascal =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pascal"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the upperSnake variant of hydra.util.CaseConvention+caseConventionUpperSnake :: Typed.TypedTerm Util.CaseConvention+caseConventionUpperSnake =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "upperSnake"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the equalTo variant of hydra.util.Comparison+comparisonEqualTo :: Typed.TypedTerm Util.Comparison+comparisonEqualTo =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "equalTo"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the greaterThan variant of hydra.util.Comparison+comparisonGreaterThan :: Typed.TypedTerm Util.Comparison+comparisonGreaterThan =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "greaterThan"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the lessThan variant of hydra.util.Comparison+comparisonLessThan :: Typed.TypedTerm Util.Comparison+comparisonLessThan =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lessThan"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL constructor for the hydra.util.FileExtension wrapper+fileExtension :: Typed.TypedTerm String -> Typed.TypedTerm Util.FileExtension+fileExtension x =+    Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.util.FileExtension"),+      Core.wrappedTermBody = (Typed.unTypedTerm x)}))+-- | DSL constructor for hydra.util.ModuleNames+moduleNames :: Typed.TypedTerm (Packaging.ModuleName, n) -> Typed.TypedTerm (M.Map Packaging.ModuleName n) -> Typed.TypedTerm (Util.ModuleNames n)+moduleNames focus mapping =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.ModuleNames"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "focus"),+          Core.fieldTerm = (Typed.unTypedTerm focus)},+        Core.Field {+          Core.fieldName = (Core.Name "mapping"),+          Core.fieldTerm = (Typed.unTypedTerm mapping)}]}))+-- | DSL accessor for the focus field of hydra.util.ModuleNames+moduleNamesFocus :: Typed.TypedTerm (Util.ModuleNames n) -> Typed.TypedTerm (Packaging.ModuleName, n)+moduleNamesFocus x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"),+        Core.projectionFieldName = (Core.Name "focus")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the mapping field of hydra.util.ModuleNames+moduleNamesMapping :: Typed.TypedTerm (Util.ModuleNames n) -> Typed.TypedTerm (M.Map Packaging.ModuleName n)+moduleNamesMapping x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"),+        Core.projectionFieldName = (Core.Name "mapping")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the focus field of hydra.util.ModuleNames+moduleNamesWithFocus :: Typed.TypedTerm (Util.ModuleNames n) -> Typed.TypedTerm (Packaging.ModuleName, n) -> Typed.TypedTerm (Util.ModuleNames n)+moduleNamesWithFocus original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.ModuleNames"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "focus"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "mapping"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"),+              Core.projectionFieldName = (Core.Name "mapping")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the mapping field of hydra.util.ModuleNames+moduleNamesWithMapping :: Typed.TypedTerm (Util.ModuleNames n) -> Typed.TypedTerm (M.Map Packaging.ModuleName n) -> Typed.TypedTerm (Util.ModuleNames n)+moduleNamesWithMapping original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.ModuleNames"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "focus"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"),+              Core.projectionFieldName = (Core.Name "focus")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "mapping"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL injection for the arbitrary variant of hydra.util.Precision+precisionArbitrary :: Typed.TypedTerm Util.Precision+precisionArbitrary =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.Precision"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "arbitrary"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the bits variant of hydra.util.Precision+precisionBits :: Typed.TypedTerm Int -> Typed.TypedTerm Util.Precision+precisionBits x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.Precision"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "bits"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL constructor for hydra.util.QualifiedName+qualifiedName :: Typed.TypedTerm (Maybe Packaging.ModuleName) -> Typed.TypedTerm String -> Typed.TypedTerm Util.QualifiedName+qualifiedName moduleName local =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.QualifiedName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm moduleName)},+        Core.Field {+          Core.fieldName = (Core.Name "local"),+          Core.fieldTerm = (Typed.unTypedTerm local)}]}))+-- | DSL accessor for the local field of hydra.util.QualifiedName+qualifiedNameLocal :: Typed.TypedTerm Util.QualifiedName -> Typed.TypedTerm String+qualifiedNameLocal x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"),+        Core.projectionFieldName = (Core.Name "local")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the moduleName field of hydra.util.QualifiedName+qualifiedNameModuleName :: Typed.TypedTerm Util.QualifiedName -> Typed.TypedTerm (Maybe Packaging.ModuleName)+qualifiedNameModuleName x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"),+        Core.projectionFieldName = (Core.Name "moduleName")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the local field of hydra.util.QualifiedName+qualifiedNameWithLocal :: Typed.TypedTerm Util.QualifiedName -> Typed.TypedTerm String -> Typed.TypedTerm Util.QualifiedName+qualifiedNameWithLocal original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.QualifiedName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"),+              Core.projectionFieldName = (Core.Name "moduleName")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "local"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the moduleName field of hydra.util.QualifiedName+qualifiedNameWithModuleName :: Typed.TypedTerm Util.QualifiedName -> Typed.TypedTerm (Maybe Packaging.ModuleName) -> Typed.TypedTerm Util.QualifiedName+qualifiedNameWithModuleName original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.QualifiedName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "local"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"),+              Core.projectionFieldName = (Core.Name "local")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL accessor for the body of hydra.util.FileExtension+unFileExtension :: Typed.TypedTerm Util.FileExtension -> Typed.TypedTerm String+unFileExtension x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.util.FileExtension")),+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+ src/main/haskell/Hydra/Dsl/Validation.hs view
@@ -0,0 +1,243 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.validation++module Hydra.Dsl.Validation where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Dsl.Error.Core as DslErrorCore+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Typed as Typed+import qualified Hydra.Validation as Validation+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | DSL constructor for hydra.validation.ValidationProfile+validationProfile :: Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Int -> Typed.TypedTerm Int -> Typed.TypedTerm Validation.ValidationProfile+validationProfile errorRules warningRules maxErrors maxWarnings =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errorRules"),+          Core.fieldTerm = (Typed.unTypedTerm errorRules)},+        Core.Field {+          Core.fieldName = (Core.Name "warningRules"),+          Core.fieldTerm = (Typed.unTypedTerm warningRules)},+        Core.Field {+          Core.fieldName = (Core.Name "maxErrors"),+          Core.fieldTerm = (Typed.unTypedTerm maxErrors)},+        Core.Field {+          Core.fieldName = (Core.Name "maxWarnings"),+          Core.fieldTerm = (Typed.unTypedTerm maxWarnings)}]}))+-- | DSL accessor for the errorRules field of hydra.validation.ValidationProfile+validationProfileErrorRules :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm (S.Set Core.Name)+validationProfileErrorRules x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+        Core.projectionFieldName = (Core.Name "errorRules")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the maxErrors field of hydra.validation.ValidationProfile+validationProfileMaxErrors :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm Int+validationProfileMaxErrors x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+        Core.projectionFieldName = (Core.Name "maxErrors")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the maxWarnings field of hydra.validation.ValidationProfile+validationProfileMaxWarnings :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm Int+validationProfileMaxWarnings x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+        Core.projectionFieldName = (Core.Name "maxWarnings")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the warningRules field of hydra.validation.ValidationProfile+validationProfileWarningRules :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm (S.Set Core.Name)+validationProfileWarningRules x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+        Core.projectionFieldName = (Core.Name "warningRules")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the errorRules field of hydra.validation.ValidationProfile+validationProfileWithErrorRules :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Validation.ValidationProfile+validationProfileWithErrorRules original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errorRules"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "warningRules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "warningRules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "maxErrors"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "maxErrors")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "maxWarnings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "maxWarnings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the maxErrors field of hydra.validation.ValidationProfile+validationProfileWithMaxErrors :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm Int -> Typed.TypedTerm Validation.ValidationProfile+validationProfileWithMaxErrors original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errorRules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "errorRules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "warningRules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "warningRules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "maxErrors"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "maxWarnings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "maxWarnings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the maxWarnings field of hydra.validation.ValidationProfile+validationProfileWithMaxWarnings :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm Int -> Typed.TypedTerm Validation.ValidationProfile+validationProfileWithMaxWarnings original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errorRules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "errorRules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "warningRules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "warningRules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "maxErrors"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "maxErrors")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "maxWarnings"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))+-- | DSL updater for the warningRules field of hydra.validation.ValidationProfile+validationProfileWithWarningRules :: Typed.TypedTerm Validation.ValidationProfile -> Typed.TypedTerm (S.Set Core.Name) -> Typed.TypedTerm Validation.ValidationProfile+validationProfileWithWarningRules original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errorRules"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "errorRules")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "warningRules"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "maxErrors"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "maxErrors")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "maxWarnings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+              Core.projectionFieldName = (Core.Name "maxWarnings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL constructor for hydra.validation.ValidationResult+validationResult :: Typed.TypedTerm [e] -> Typed.TypedTerm [e] -> Typed.TypedTerm (Validation.ValidationResult e)+validationResult errors warnings =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errors"),+          Core.fieldTerm = (Typed.unTypedTerm errors)},+        Core.Field {+          Core.fieldName = (Core.Name "warnings"),+          Core.fieldTerm = (Typed.unTypedTerm warnings)}]}))+-- | DSL accessor for the errors field of hydra.validation.ValidationResult+validationResultErrors :: Typed.TypedTerm (Validation.ValidationResult e) -> Typed.TypedTerm [e]+validationResultErrors x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"),+        Core.projectionFieldName = (Core.Name "errors")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL accessor for the warnings field of hydra.validation.ValidationResult+validationResultWarnings :: Typed.TypedTerm (Validation.ValidationResult e) -> Typed.TypedTerm [e]+validationResultWarnings x =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermProject (Core.Projection {+        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"),+        Core.projectionFieldName = (Core.Name "warnings")})),+      Core.applicationArgument = (Typed.unTypedTerm x)}))+-- | DSL updater for the errors field of hydra.validation.ValidationResult+validationResultWithErrors :: Typed.TypedTerm (Validation.ValidationResult e) -> Typed.TypedTerm [e] -> Typed.TypedTerm (Validation.ValidationResult e)+validationResultWithErrors original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errors"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)},+        Core.Field {+          Core.fieldName = (Core.Name "warnings"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"),+              Core.projectionFieldName = (Core.Name "warnings")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))+-- | DSL updater for the warnings field of hydra.validation.ValidationResult+validationResultWithWarnings :: Typed.TypedTerm (Validation.ValidationResult e) -> Typed.TypedTerm [e] -> Typed.TypedTerm (Validation.ValidationResult e)+validationResultWithWarnings original newVal =+    Typed.TypedTerm (Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.validation.ValidationResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "errors"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermProject (Core.Projection {+              Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"),+              Core.projectionFieldName = (Core.Name "errors")})),+            Core.applicationArgument = (Typed.unTypedTerm original)}))},+        Core.Field {+          Core.fieldName = (Core.Name "warnings"),+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+ src/main/haskell/Hydra/Dsl/Variants.hs view
@@ -0,0 +1,362 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.variants++module Hydra.Dsl.Variants where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Typed as Typed+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | DSL injection for the binary variant of hydra.variants.LiteralVariant+literalVariantBinary :: Typed.TypedTerm Variants.LiteralVariant+literalVariantBinary =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "binary"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the boolean variant of hydra.variants.LiteralVariant+literalVariantBoolean :: Typed.TypedTerm Variants.LiteralVariant+literalVariantBoolean =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "boolean"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the decimal variant of hydra.variants.LiteralVariant+literalVariantDecimal :: Typed.TypedTerm Variants.LiteralVariant+literalVariantDecimal =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "decimal"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the float variant of hydra.variants.LiteralVariant+literalVariantFloat :: Typed.TypedTerm Variants.LiteralVariant+literalVariantFloat =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the integer variant of hydra.variants.LiteralVariant+literalVariantInteger :: Typed.TypedTerm Variants.LiteralVariant+literalVariantInteger =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "integer"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the string variant of hydra.variants.LiteralVariant+literalVariantString :: Typed.TypedTerm Variants.LiteralVariant+literalVariantString =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "string"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the annotated variant of hydra.variants.TermVariant+termVariantAnnotated :: Typed.TypedTerm Variants.TermVariant+termVariantAnnotated =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotated"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the application variant of hydra.variants.TermVariant+termVariantApplication :: Typed.TypedTerm Variants.TermVariant+termVariantApplication =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "application"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the cases variant of hydra.variants.TermVariant+termVariantCases :: Typed.TypedTerm Variants.TermVariant+termVariantCases =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "cases"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the either variant of hydra.variants.TermVariant+termVariantEither :: Typed.TypedTerm Variants.TermVariant+termVariantEither =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "either"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the inject variant of hydra.variants.TermVariant+termVariantInject :: Typed.TypedTerm Variants.TermVariant+termVariantInject =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "inject"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the lambda variant of hydra.variants.TermVariant+termVariantLambda :: Typed.TypedTerm Variants.TermVariant+termVariantLambda =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "lambda"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the let variant of hydra.variants.TermVariant+termVariantLet :: Typed.TypedTerm Variants.TermVariant+termVariantLet =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "let"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the list variant of hydra.variants.TermVariant+termVariantList :: Typed.TypedTerm Variants.TermVariant+termVariantList =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "list"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the literal variant of hydra.variants.TermVariant+termVariantLiteral :: Typed.TypedTerm Variants.TermVariant+termVariantLiteral =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the map variant of hydra.variants.TermVariant+termVariantMap :: Typed.TypedTerm Variants.TermVariant+termVariantMap =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "map"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the optional variant of hydra.variants.TermVariant+termVariantOptional :: Typed.TypedTerm Variants.TermVariant+termVariantOptional =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optional"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the pair variant of hydra.variants.TermVariant+termVariantPair :: Typed.TypedTerm Variants.TermVariant+termVariantPair =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pair"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the project variant of hydra.variants.TermVariant+termVariantProject :: Typed.TypedTerm Variants.TermVariant+termVariantProject =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "project"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the record variant of hydra.variants.TermVariant+termVariantRecord :: Typed.TypedTerm Variants.TermVariant+termVariantRecord =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "record"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the set variant of hydra.variants.TermVariant+termVariantSet :: Typed.TypedTerm Variants.TermVariant+termVariantSet =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "set"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the typeApplication variant of hydra.variants.TermVariant+termVariantTypeApplication :: Typed.TypedTerm Variants.TermVariant+termVariantTypeApplication =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeApplication"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the typeLambda variant of hydra.variants.TermVariant+termVariantTypeLambda :: Typed.TypedTerm Variants.TermVariant+termVariantTypeLambda =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "typeLambda"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the unit variant of hydra.variants.TermVariant+termVariantUnit :: Typed.TypedTerm Variants.TermVariant+termVariantUnit =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unit"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the unwrap variant of hydra.variants.TermVariant+termVariantUnwrap :: Typed.TypedTerm Variants.TermVariant+termVariantUnwrap =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unwrap"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the variable variant of hydra.variants.TermVariant+termVariantVariable :: Typed.TypedTerm Variants.TermVariant+termVariantVariable =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "variable"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the wrap variant of hydra.variants.TermVariant+termVariantWrap :: Typed.TypedTerm Variants.TermVariant+termVariantWrap =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrap"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the annotated variant of hydra.variants.TypeVariant+typeVariantAnnotated :: Typed.TypedTerm Variants.TypeVariant+typeVariantAnnotated =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "annotated"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the application variant of hydra.variants.TypeVariant+typeVariantApplication :: Typed.TypedTerm Variants.TypeVariant+typeVariantApplication =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "application"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the either variant of hydra.variants.TypeVariant+typeVariantEither :: Typed.TypedTerm Variants.TypeVariant+typeVariantEither =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "either"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the forall variant of hydra.variants.TypeVariant+typeVariantForall :: Typed.TypedTerm Variants.TypeVariant+typeVariantForall =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "forall"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the function variant of hydra.variants.TypeVariant+typeVariantFunction :: Typed.TypedTerm Variants.TypeVariant+typeVariantFunction =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "function"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the list variant of hydra.variants.TypeVariant+typeVariantList :: Typed.TypedTerm Variants.TypeVariant+typeVariantList =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "list"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the literal variant of hydra.variants.TypeVariant+typeVariantLiteral :: Typed.TypedTerm Variants.TypeVariant+typeVariantLiteral =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "literal"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the map variant of hydra.variants.TypeVariant+typeVariantMap :: Typed.TypedTerm Variants.TypeVariant+typeVariantMap =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "map"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the optional variant of hydra.variants.TypeVariant+typeVariantOptional :: Typed.TypedTerm Variants.TypeVariant+typeVariantOptional =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "optional"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the pair variant of hydra.variants.TypeVariant+typeVariantPair :: Typed.TypedTerm Variants.TypeVariant+typeVariantPair =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "pair"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the record variant of hydra.variants.TypeVariant+typeVariantRecord :: Typed.TypedTerm Variants.TypeVariant+typeVariantRecord =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "record"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the set variant of hydra.variants.TypeVariant+typeVariantSet :: Typed.TypedTerm Variants.TypeVariant+typeVariantSet =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "set"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the union variant of hydra.variants.TypeVariant+typeVariantUnion :: Typed.TypedTerm Variants.TypeVariant+typeVariantUnion =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "union"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the unit variant of hydra.variants.TypeVariant+typeVariantUnit :: Typed.TypedTerm Variants.TypeVariant+typeVariantUnit =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "unit"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the variable variant of hydra.variants.TypeVariant+typeVariantVariable :: Typed.TypedTerm Variants.TypeVariant+typeVariantVariable =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "variable"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the void variant of hydra.variants.TypeVariant+typeVariantVoid :: Typed.TypedTerm Variants.TypeVariant+typeVariantVoid =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "void"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the wrap variant of hydra.variants.TypeVariant+typeVariantWrap :: Typed.TypedTerm Variants.TypeVariant+typeVariantWrap =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "wrap"),+        Core.fieldTerm = Core.TermUnit}}))
+ src/main/haskell/Hydra/Dsl/Yaml/Model.hs view
@@ -0,0 +1,83 @@+-- Note: this is an automatically generated file. Do not edit.+-- | DSL functions for hydra.yaml.model++module Hydra.Dsl.Yaml.Model where+import qualified Hydra.Core as Core+import qualified Hydra.Dsl.Core as DslCore+import qualified Hydra.Typed as Typed+import qualified Hydra.Yaml.Model as Model+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | DSL injection for the mapping variant of hydra.yaml.model.Node+nodeMapping :: Typed.TypedTerm (M.Map Model.Node Model.Node) -> Typed.TypedTerm Model.Node+nodeMapping x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "mapping"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the scalar variant of hydra.yaml.model.Node+nodeScalar :: Typed.TypedTerm Model.Scalar -> Typed.TypedTerm Model.Node+nodeScalar x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "scalar"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the sequence variant of hydra.yaml.model.Node+nodeSequence :: Typed.TypedTerm [Model.Node] -> Typed.TypedTerm Model.Node+nodeSequence x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Node"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "sequence"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the bool variant of hydra.yaml.model.Scalar+scalarBool :: Typed.TypedTerm Bool -> Typed.TypedTerm Model.Scalar+scalarBool x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "bool"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the decimal variant of hydra.yaml.model.Scalar+scalarDecimal :: Typed.TypedTerm Sci.Scientific -> Typed.TypedTerm Model.Scalar+scalarDecimal x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "decimal"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the float variant of hydra.yaml.model.Scalar+scalarFloat :: Typed.TypedTerm Double -> Typed.TypedTerm Model.Scalar+scalarFloat x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "float"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the int variant of hydra.yaml.model.Scalar+scalarInt :: Typed.TypedTerm Integer -> Typed.TypedTerm Model.Scalar+scalarInt x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "int"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))+-- | DSL injection for the null variant of hydra.yaml.model.Scalar+scalarNull :: Typed.TypedTerm Model.Scalar+scalarNull =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "null"),+        Core.fieldTerm = Core.TermUnit}}))+-- | DSL injection for the str variant of hydra.yaml.model.Scalar+scalarStr :: Typed.TypedTerm String -> Typed.TypedTerm Model.Scalar+scalarStr x =+    Typed.TypedTerm (Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.yaml.model.Scalar"),+      Core.injectionField = Core.Field {+        Core.fieldName = (Core.Name "str"),+        Core.fieldTerm = (Typed.unTypedTerm x)}}))
+ src/main/haskell/Hydra/Dsls.hs view
@@ -0,0 +1,592 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Functions for generating domain-specific DSL modules from type modules++module Hydra.Dsls where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Collect forall type variable names from a type+collectForallVars :: Core.Type -> [Core.Name]+collectForallVars typ =+    case typ of+      Core.TypeAnnotated v0 -> collectForallVars (Core.annotatedTypeBody v0)+      Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (collectForallVars (Core.forallTypeBody v0))+      _ -> []+-- | Deduplicate bindings by appending numeric suffixes to duplicate names+deduplicateBindings :: [Core.Binding] -> [Core.Binding]+deduplicateBindings bindings =+    Lists.foldl (\acc -> \b ->+      let usedNames = Sets.fromList (Lists.map (\a -> Core.bindingName a) acc)+          uniqueName = Lexical.chooseUniqueName usedNames (Core.bindingName b)+      in (Lists.concat2 acc [+        Core.Binding {+          Core.bindingName = uniqueName,+          Core.bindingTerm = (Core.bindingTerm b),+          Core.bindingTypeScheme = (Core.bindingTypeScheme b)}])) [] bindings+-- | Generate a binding name for a DSL function from a type name+dslBindingName :: Core.Name -> Core.Name+dslBindingName 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 (\nsHeadTail ->+        let dslNsParts =+                Logic.ifElse (Equality.equal (Pairs.first nsHeadTail) "hydra") (Lists.concat2 [+                  "hydra",+                  "dsl"] (Pairs.second nsHeadTail)) (Lists.concat2 [+                  "hydra",+                  "dsl"] nsParts)+        in (Core.Name (Strings.intercalate "." (Lists.concat2 dslNsParts [+          localPart]))))))+-- | Generate a qualified DSL element name from a type name and local element name+dslDefinitionName :: Core.Name -> String -> Core.Name+dslDefinitionName typeName localName =++      let parts = Strings.splitOn "." (Core.unName typeName)+      in (Optionals.cases (Lists.maybeInit parts) (Core.Name localName) (\nsParts ->+        let dslNsParts =+                Optionals.cases (Lists.uncons nsParts) [+                  "hydra",+                  "dsl"] (\nsHeadTail -> Logic.ifElse (Equality.equal (Pairs.first nsHeadTail) "hydra") (Lists.concat2 [+                  "hydra",+                  "dsl"] (Pairs.second nsHeadTail)) (Lists.concat2 [+                  "hydra",+                  "dsl"] nsParts))+        in (Core.Name (Strings.intercalate "." (Lists.concat2 dslNsParts [+          localName])))))+-- | Transform a type module into a DSL module+dslModule :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error (Maybe Packaging.Module)+dslModule 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) (generateBindingsForType cx graph b)) typeBindings) (\dslBindings -> Right (Just (Packaging.Module {+      Packaging.moduleName = (dslModuleName (Packaging.moduleName mod)),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just (Strings.cat [+          "DSL functions 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.nub (Lists.concat2 [+        Packaging.moduleName mod,+        (Packaging.ModuleName "hydra.typed")] (Lists.concat2 (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod)) (Lists.map dslModuleName (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))))))),+      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)})) (deduplicateBindings (Lists.concat dslBindings)))})))))+-- | Generate a DSL module name from a source module name+dslModuleName :: Packaging.ModuleName -> Packaging.ModuleName+dslModuleName ns =++      let parts = Strings.splitOn "." (Packaging.unModuleName ns)+          prefixFull =+                  Packaging.ModuleName (Strings.cat [+                    "hydra.dsl.",+                    (Packaging.unModuleName ns)])+      in (Optionals.cases (Lists.uncons parts) prefixFull (\ht -> Logic.ifElse (Equality.equal (Pairs.first ht) "hydra") (Packaging.ModuleName (Strings.cat [+        "hydra.dsl.",+        (Strings.intercalate "." (Pairs.second ht))])) prefixFull))+-- | Build a TypeScheme with TypedTerm-wrapped parameter and result types+dslTypeScheme :: Core.Type -> [Core.Type] -> Core.Type -> Core.TypeScheme+dslTypeScheme origType paramTypes resultType =++      let typeVars = collectForallVars origType+          wrappedResult =+                  Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationTypeArgument = resultType})+          funType =+                  Lists.foldr (\paramType -> \acc -> Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeApplication (Core.ApplicationType {+                      Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                      Core.applicationTypeArgument = paramType})),+                    Core.functionTypeCodomain = acc})) wrappedResult paramTypes+      in Core.TypeScheme {+        Core.typeSchemeVariables = typeVars,+        Core.typeSchemeBody = funType,+        Core.typeSchemeConstraints = Nothing}+-- | Filter bindings to only DSL-eligible type definitions+filterTypeBindings :: t0 -> t1 -> [Core.Binding] -> Either t2 [Core.Binding]+filterTypeBindings cx graph bindings =+    Eithers.map Optionals.cat (Eithers.mapList (isDslEligibleBinding cx graph) (Lists.filter Annotations.isNativeType bindings))+-- | Generate all DSL bindings for a type binding+generateBindingsForType :: t0 -> Graph.Graph -> Core.Binding -> Either Errors.DecodingError [Core.Binding]+generateBindingsForType cx graph b =++      let typeName = Core.bindingName b+      in (Eithers.bind (DecodeCore.type_ graph (Core.bindingTerm b)) (\rawType ->+        let typ = Strip.deannotateTypeParameters (Strip.deannotateType rawType)+        in (Right (case typ of+          Core.TypeRecord v0 -> Lists.concat [+            generateRecordConstructor rawType typeName v0,+            (Lists.map (generateRecordAccessor rawType typeName) v0),+            (Lists.map (generateRecordWithUpdater rawType typeName v0) v0)]+          Core.TypeUnion v0 -> Lists.map (generateUnionInjector rawType typeName) v0+          Core.TypeWrap v0 -> generateWrappedTypeAccessors rawType typeName v0+          _ -> []))))+-- | Generate a record field accessor function+generateRecordAccessor :: Core.Type -> Core.Name -> Core.FieldType -> Core.Binding+generateRecordAccessor origType typeName ft =++      let fieldName = Core.fieldTypeName ft+          accessorLocalName =+                  Strings.cat [+                    Formatting.decapitalize (Names.localNameOf typeName),+                    (Strings.intercalate "" (Lists.map (\s -> Formatting.capitalize s) (Strings.splitOn "." (Core.unName fieldName))))]+          accessorName = dslDefinitionName typeName accessorLocalName+          paramDomain =+                  Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationTypeArgument = (nominalResultType typeName origType)})+          rawBody =+                  Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = (Just paramDomain),+                    Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                      Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+                      Core.wrappedTermBody = (Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                        Core.injectionField = Core.Field {+                          Core.fieldName = (Core.Name "application"),+                          Core.fieldTerm = (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Application"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "function"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "project"),+                                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                                      Core.recordTypeName = (Core.Name "hydra.core.Projection"),+                                      Core.recordFields = [+                                        Core.Field {+                                          Core.fieldName = (Core.Name "typeName"),+                                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))},+                                        Core.Field {+                                          Core.fieldName = (Core.Name "fieldName"),+                                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName fieldName)))}))}]}))}}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "argument"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}]}))}}))}))})+          description =+                  Strings.cat [+                    "DSL accessor for the ",+                    (Core.unName fieldName),+                    " field of ",+                    (Core.unName typeName)]+          body = Annotations.setTermDescription (Just description) rawBody+          ts = dslTypeScheme origType [+                nominalResultType typeName origType] (Core.fieldTypeType ft)+      in Core.Binding {+        Core.bindingName = accessorName,+        Core.bindingTerm = body,+        Core.bindingTypeScheme = (Just ts)}+-- | Generate a record constructor function+generateRecordConstructor :: Core.Type -> Core.Name -> [Core.FieldType] -> [Core.Binding]+generateRecordConstructor origType typeName fieldTypes =++      let dFields =+              Lists.map (\ft -> Core.TermRecord (Core.Record {+                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                Core.recordFields = [+                  Core.Field {+                    Core.fieldName = (Core.Name "name"),+                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}))},+                  Core.Field {+                    Core.fieldName = (Core.Name "term"),+                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name (Formatting.decapitalize (Names.localNameOf (Core.fieldTypeName ft)))))}))}]})) fieldTypes+          recordTerm =+                  Core.TermWrap (Core.WrappedTerm {+                    Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+                    Core.wrappedTermBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "record"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Record"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "fields"),+                              Core.fieldTerm = (Core.TermList dFields)}]}))}}))})+          paramPairs =+                  Lists.map (\ft -> (+                    Formatting.decapitalize (Names.localNameOf (Core.fieldTypeName ft)),+                    (Core.TypeApplication (Core.ApplicationType {+                      Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                      Core.applicationTypeArgument = (Core.fieldTypeType ft)})))) fieldTypes+          rawBody =+                  Lists.foldl (\acc -> \pp -> Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name (Pairs.first pp)),+                    Core.lambdaDomain = (Just (Pairs.second pp)),+                    Core.lambdaBody = acc})) recordTerm (Lists.reverse paramPairs)+          description =+                  Strings.cat [+                    "DSL constructor for ",+                    (Core.unName typeName)]+          body = Annotations.setTermDescription (Just description) rawBody+          paramTypes = Lists.map (\ft -> Core.fieldTypeType ft) fieldTypes+          resultType = nominalResultType typeName origType+          ts = dslTypeScheme origType paramTypes resultType+      in [+        Core.Binding {+          Core.bindingName = (dslBindingName typeName),+          Core.bindingTerm = body,+          Core.bindingTypeScheme = (Just ts)}]+-- | Generate a withXxx record field updater function+generateRecordWithUpdater :: Core.Type -> Core.Name -> [Core.FieldType] -> Core.FieldType -> Core.Binding+generateRecordWithUpdater origType typeName allFields targetField =++      let targetFieldName = Core.fieldTypeName targetField+          updaterLocalName =+                  Strings.cat [+                    Formatting.decapitalize (Names.localNameOf typeName),+                    "With",+                    (Strings.intercalate "" (Lists.map (\s -> Formatting.capitalize s) (Strings.splitOn "." (Core.unName targetFieldName))))]+          updaterName = dslDefinitionName typeName updaterLocalName+          dFields =+                  Lists.map (\ft -> Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Field"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "name"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "term"),+                        Core.fieldTerm = (Logic.ifElse (Equality.equal (Core.unName (Core.fieldTypeName ft)) (Core.unName targetFieldName)) (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "newVal"))})) (Core.TermInject (Core.Injection {+                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                          Core.injectionField = Core.Field {+                            Core.fieldName = (Core.Name "application"),+                            Core.fieldTerm = (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Application"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "function"),+                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                    Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                    Core.injectionField = Core.Field {+                                      Core.fieldName = (Core.Name "project"),+                                      Core.fieldTerm = (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.core.Projection"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "typeName"),+                                            Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))},+                                          Core.Field {+                                            Core.fieldName = (Core.Name "fieldName"),+                                            Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName (Core.fieldTypeName ft))))}))}]}))}}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "argument"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "original"))}))}]}))}})))}]})) allFields+          recDomain =+                  Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationTypeArgument = (nominalResultType typeName origType)})+          fieldDomain =+                  Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationTypeArgument = (Core.fieldTypeType targetField)})+          rawBody =+                  Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "original"),+                    Core.lambdaDomain = (Just recDomain),+                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "newVal"),+                      Core.lambdaDomain = (Just fieldDomain),+                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                        Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+                        Core.wrappedTermBody = (Core.TermInject (Core.Injection {+                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                          Core.injectionField = Core.Field {+                            Core.fieldName = (Core.Name "record"),+                            Core.fieldTerm = (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Record"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "typeName"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "fields"),+                                  Core.fieldTerm = (Core.TermList dFields)}]}))}}))}))}))})+          description =+                  Strings.cat [+                    "DSL updater for the ",+                    (Core.unName targetFieldName),+                    " field of ",+                    (Core.unName typeName)]+          body = Annotations.setTermDescription (Just description) rawBody+          recType = nominalResultType typeName origType+          ts =+                  dslTypeScheme origType [+                    recType,+                    (Core.fieldTypeType targetField)] recType+      in Core.Binding {+        Core.bindingName = updaterName,+        Core.bindingTerm = body,+        Core.bindingTypeScheme = (Just ts)}+-- | Generate a union injection helper+generateUnionInjector :: Core.Type -> Core.Name -> Core.FieldType -> Core.Binding+generateUnionInjector origType typeName ft =++      let fieldName = Core.fieldTypeName ft+          fieldType = Core.fieldTypeType ft+          injectorLocalName =+                  Strings.cat [+                    Formatting.decapitalize (Names.localNameOf typeName),+                    (Strings.intercalate "" (Lists.map (\s -> Formatting.capitalize s) (Strings.splitOn "." (Core.unName fieldName))))]+          injectorName = dslDefinitionName typeName injectorLocalName+          isUnit =+                  (\t -> case (Strip.deannotateType t) of+                    Core.TypeUnit -> True+                    _ -> False) fieldType+          dFieldValue =+                  Logic.ifElse isUnit (Core.TermInject (Core.Injection {+                    Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                    Core.injectionField = Core.Field {+                      Core.fieldName = (Core.Name "unit"),+                      Core.fieldTerm = Core.TermUnit}})) (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))+          injectionTerm =+                  Core.TermWrap (Core.WrappedTerm {+                    Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+                    Core.wrappedTermBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName fieldName)))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = dFieldValue}]}))}]}))}}))})+          variantDomain =+                  Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationTypeArgument = (Core.fieldTypeType ft)})+          rawBody =+                  Logic.ifElse isUnit injectionTerm (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = (Just variantDomain),+                    Core.lambdaBody = injectionTerm}))+          description =+                  Strings.cat [+                    "DSL injection for the ",+                    (Core.unName fieldName),+                    " variant of ",+                    (Core.unName typeName)]+          body = Annotations.setTermDescription (Just description) rawBody+          unionType = nominalResultType typeName origType+          ts = Logic.ifElse isUnit (dslTypeScheme origType [] unionType) (dslTypeScheme origType [+                Core.fieldTypeType ft] unionType)+      in Core.Binding {+        Core.bindingName = injectorName,+        Core.bindingTerm = body,+        Core.bindingTypeScheme = (Just ts)}+-- | Generate wrap/unwrap accessors for a wrapped type+generateWrappedTypeAccessors :: Core.Type -> Core.Name -> Core.Type -> [Core.Binding]+generateWrappedTypeAccessors origType typeName innerType =++      let localName = Names.localNameOf typeName+          wrapName = dslDefinitionName typeName (Formatting.decapitalize localName)+          unwrapLocalName =+                  Strings.cat [+                    "un",+                    localName]+          unwrapName = dslDefinitionName typeName unwrapLocalName+          wrapperType = nominalResultType typeName origType+          wrapDomain =+                  Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationTypeArgument = innerType})+          rawWrapBody =+                  Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = (Just wrapDomain),+                    Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                      Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+                      Core.wrappedTermBody = (Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                        Core.injectionField = Core.Field {+                          Core.fieldName = (Core.Name "wrap"),+                          Core.fieldTerm = (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "typeName"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "body"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}]}))}}))}))})+          wrapDescription =+                  Strings.cat [+                    "DSL constructor for the ",+                    (Core.unName typeName),+                    " wrapper"]+          wrapBody = Annotations.setTermDescription (Just wrapDescription) rawWrapBody+          unwrapDomain =+                  Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                    Core.applicationTypeArgument = wrapperType})+          rawUnwrapBody =+                  Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = (Just unwrapDomain),+                    Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                      Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+                      Core.wrappedTermBody = (Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                        Core.injectionField = Core.Field {+                          Core.fieldName = (Core.Name "application"),+                          Core.fieldTerm = (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Application"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "function"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "unwrap"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName typeName)))}))}}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "argument"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}]}))}}))}))})+          unwrapDescription =+                  Strings.cat [+                    "DSL accessor for the body of ",+                    (Core.unName typeName)]+          unwrapBody = Annotations.setTermDescription (Just unwrapDescription) rawUnwrapBody+          wrapTs = dslTypeScheme origType [+                innerType] wrapperType+          unwrapTs = dslTypeScheme origType [+                wrapperType] innerType+      in [+        Core.Binding {+          Core.bindingName = wrapName,+          Core.bindingTerm = wrapBody,+          Core.bindingTypeScheme = (Just wrapTs)},+        Core.Binding {+          Core.bindingName = unwrapName,+          Core.bindingTerm = unwrapBody,+          Core.bindingTypeScheme = (Just unwrapTs)}]+-- | Check if a binding is eligible for DSL generation+isDslEligibleBinding :: t0 -> t1 -> Core.Binding -> Either t2 (Maybe Core.Binding)+isDslEligibleBinding cx graph b =++      let ns = Names.moduleNameOf (Core.bindingName b)+      in (Logic.ifElse (Equality.equal (Optionals.cases ns "" Packaging.unModuleName) "hydra.typed") (Right Nothing) (Right (Just b)))+-- | Build the nominal result type with type applications for forall variables+nominalResultType :: Core.Name -> Core.Type -> Core.Type+nominalResultType typeName origType =++      let vars = collectForallVars origType+      in (Lists.foldl (\acc -> \v -> Core.TypeApplication (Core.ApplicationType {+        Core.applicationTypeFunction = acc,+        Core.applicationTypeArgument = (Core.TypeVariable v)})) (Core.TypeVariable typeName) vars)
+ src/main/haskell/Hydra/Encode/Ast.hs view
@@ -0,0 +1,230 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.ast++module Hydra.Encode.Ast where+import qualified Hydra.Ast as Ast+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.ast.Associativity+associativity :: Ast.Associativity -> Core.Term+associativity x =+    case x of+      Ast.AssociativityNone -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "none"),+          Core.fieldTerm = Core.TermUnit}})+      Ast.AssociativityLeft -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = Core.TermUnit}})+      Ast.AssociativityRight -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = Core.TermUnit}})+      Ast.AssociativityBoth -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "both"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.ast.BlockStyle+blockStyle :: Ast.BlockStyle -> Core.Term+blockStyle x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "indent"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Ast.blockStyleIndent x))},+        Core.Field {+          Core.fieldName = (Core.Name "newlineBeforeContent"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Ast.blockStyleNewlineBeforeContent x))},+        Core.Field {+          Core.fieldName = (Core.Name "newlineAfterContent"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Ast.blockStyleNewlineAfterContent x))}]})+-- | Encoder for hydra.ast.BracketExpr+bracketExpr :: Ast.BracketExpr -> Core.Term+bracketExpr x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "brackets"),+          Core.fieldTerm = (brackets (Ast.bracketExprBrackets x))},+        Core.Field {+          Core.fieldName = (Core.Name "enclosed"),+          Core.fieldTerm = (expr (Ast.bracketExprEnclosed x))},+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (blockStyle (Ast.bracketExprStyle x))}]})+-- | Encoder for hydra.ast.Brackets+brackets :: Ast.Brackets -> Core.Term+brackets x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Brackets"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "open"),+          Core.fieldTerm = (symbol (Ast.bracketsOpen x))},+        Core.Field {+          Core.fieldName = (Core.Name "close"),+          Core.fieldTerm = (symbol (Ast.bracketsClose x))}]})+-- | Encoder for hydra.ast.Expr+expr :: Ast.Expr -> Core.Term+expr x =+    case x of+      Ast.ExprConst v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "const"),+          Core.fieldTerm = (symbol v0)}})+      Ast.ExprIndent v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "indent"),+          Core.fieldTerm = (indentedExpression v0)}})+      Ast.ExprOp v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (opExpr v0)}})+      Ast.ExprBrackets v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "brackets"),+          Core.fieldTerm = (bracketExpr v0)}})+      Ast.ExprSeq v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "seq"),+          Core.fieldTerm = (seqExpr v0)}})+-- | Encoder for hydra.ast.IndentStyle+indentStyle :: Ast.IndentStyle -> Core.Term+indentStyle x =+    case x of+      Ast.IndentStyleAllLines v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "allLines"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}})+      Ast.IndentStyleSubsequentLines v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "subsequentLines"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}})+-- | Encoder for hydra.ast.IndentedExpression+indentedExpression :: Ast.IndentedExpression -> Core.Term+indentedExpression x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "style"),+          Core.fieldTerm = (indentStyle (Ast.indentedExpressionStyle x))},+        Core.Field {+          Core.fieldName = (Core.Name "expr"),+          Core.fieldTerm = (expr (Ast.indentedExpressionExpr x))}]})+-- | Encoder for hydra.ast.Op+op :: Ast.Op -> Core.Term+op x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Op"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "symbol"),+          Core.fieldTerm = (symbol (Ast.opSymbol x))},+        Core.Field {+          Core.fieldName = (Core.Name "padding"),+          Core.fieldTerm = (padding (Ast.opPadding x))},+        Core.Field {+          Core.fieldName = (Core.Name "precedence"),+          Core.fieldTerm = (precedence (Ast.opPrecedence x))},+        Core.Field {+          Core.fieldName = (Core.Name "associativity"),+          Core.fieldTerm = (associativity (Ast.opAssociativity x))}]})+-- | Encoder for hydra.ast.OpExpr+opExpr :: Ast.OpExpr -> Core.Term+opExpr x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (op (Ast.opExprOp x))},+        Core.Field {+          Core.fieldName = (Core.Name "lhs"),+          Core.fieldTerm = (expr (Ast.opExprLhs x))},+        Core.Field {+          Core.fieldName = (Core.Name "rhs"),+          Core.fieldTerm = (expr (Ast.opExprRhs x))}]})+-- | Encoder for hydra.ast.Padding+padding :: Ast.Padding -> Core.Term+padding x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.Padding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (ws (Ast.paddingLeft x))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (ws (Ast.paddingRight x))}]})+-- | Encoder for hydra.ast.Precedence+precedence :: Ast.Precedence -> Core.Term+precedence x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Ast.unPrecedence x))})+-- | Encoder for hydra.ast.SeqExpr+seqExpr :: Ast.SeqExpr -> Core.Term+seqExpr x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "op"),+          Core.fieldTerm = (op (Ast.seqExprOp x))},+        Core.Field {+          Core.fieldName = (Core.Name "elements"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map expr xs)) (Ast.seqExprElements x))}]})+-- | Encoder for hydra.ast.Symbol+symbol :: Ast.Symbol -> Core.Term+symbol x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Ast.unSymbol x))})+-- | Encoder for hydra.ast.Ws+ws :: Ast.Ws -> Core.Term+ws x =+    case x of+      Ast.WsNone -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "none"),+          Core.fieldTerm = Core.TermUnit}})+      Ast.WsSpace -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "space"),+          Core.fieldTerm = Core.TermUnit}})+      Ast.WsBreak -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "break"),+          Core.fieldTerm = Core.TermUnit}})+      Ast.WsBreakAndIndent v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "breakAndIndent"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}})+      Ast.WsDoubleBreak -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "doubleBreak"),+          Core.fieldTerm = Core.TermUnit}})
+ src/main/haskell/Hydra/Encode/Coders.hs view
@@ -0,0 +1,102 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.coders++module Hydra.Encode.Coders where+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Errors as Errors+import qualified Hydra.Encode.Typing as Typing+import qualified Hydra.Encode.Util as Util+import qualified Hydra.Encode.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.coders.CaseConventions+caseConventions :: Coders.CaseConventions -> Core.Term+caseConventions x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "constant"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsConstant x))},+        Core.Field {+          Core.fieldName = (Core.Name "directory"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsDirectory x))},+        Core.Field {+          Core.fieldName = (Core.Name "enumValue"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsEnumValue x))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsField x))},+        Core.Field {+          Core.fieldName = (Core.Name "file"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsFile x))},+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsModule x))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsTerm x))},+        Core.Field {+          Core.fieldName = (Core.Name "termVariable"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsTermVariable x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsType x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeVariable"),+          Core.fieldTerm = (Util.caseConvention (Coders.caseConventionsTypeVariable x))}]})+-- | Encoder for hydra.coders.CoderDirection+coderDirection :: Coders.CoderDirection -> Core.Term+coderDirection x =+    case x of+      Coders.CoderDirectionEncode -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "encode"),+          Core.fieldTerm = Core.TermUnit}})+      Coders.CoderDirectionDecode -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "decode"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.coders.LanguageFeature+languageFeature :: Coders.LanguageFeature -> Core.Term+languageFeature x =+    case x of+      Coders.LanguageFeaturePartialApplication -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "partialApplication"),+          Core.fieldTerm = Core.TermUnit}})+      Coders.LanguageFeatureNestedCaseStatements -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nestedCaseStatements"),+          Core.fieldTerm = Core.TermUnit}})+      Coders.LanguageFeatureNestedPolymorphicLetBindings -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nestedPolymorphicLetBindings"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.coders.LanguageName+languageName :: Coders.LanguageName -> Core.Term+languageName x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Coders.unLanguageName x))})+-- | Encoder for hydra.coders.TraversalOrder+traversalOrder :: Coders.TraversalOrder -> Core.Term+traversalOrder x =+    case x of+      Coders.TraversalOrderPre -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pre"),+          Core.fieldTerm = Core.TermUnit}})+      Coders.TraversalOrderPost -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "post"),+          Core.fieldTerm = Core.TermUnit}})
+ src/main/haskell/Hydra/Encode/Core.hs view
@@ -0,0 +1,717 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.core++module Hydra.Encode.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.core.AnnotatedTerm+annotatedTerm :: Core.AnnotatedTerm -> Core.Term+annotatedTerm x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (term (Core.annotatedTermBody x))},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (term (Core.annotatedTermAnnotation x))}]})+-- | Encoder for hydra.core.AnnotatedType+annotatedType :: Core.AnnotatedType -> Core.Term+annotatedType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (type_ (Core.annotatedTypeBody x))},+        Core.Field {+          Core.fieldName = (Core.Name "annotation"),+          Core.fieldTerm = (term (Core.annotatedTypeAnnotation x))}]})+-- | Encoder for hydra.core.Application+application :: Core.Application -> Core.Term+application x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Application"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (term (Core.applicationFunction x))},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (term (Core.applicationArgument x))}]})+-- | Encoder for hydra.core.ApplicationType+applicationType :: Core.ApplicationType -> Core.Term+applicationType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (type_ (Core.applicationTypeFunction x))},+        Core.Field {+          Core.fieldName = (Core.Name "argument"),+          Core.fieldTerm = (type_ (Core.applicationTypeArgument x))}]})+-- | Encoder for hydra.core.Binding+binding :: Core.Binding -> Core.Term+binding x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Binding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (name (Core.bindingName x))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (term (Core.bindingTerm x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeScheme"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map typeScheme opt)) (Core.bindingTypeScheme x))}]})+-- | Encoder for hydra.core.CaseAlternative+caseAlternative :: Core.CaseAlternative -> Core.Term+caseAlternative x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseAlternative"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (name (Core.caseAlternativeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "handler"),+          Core.fieldTerm = (term (Core.caseAlternativeHandler x))}]})+-- | Encoder for hydra.core.CaseStatement+caseStatement :: Core.CaseStatement -> Core.Term+caseStatement x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (name (Core.caseStatementTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "default"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map term opt)) (Core.caseStatementDefault x))},+        Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map caseAlternative xs)) (Core.caseStatementCases x))}]})+-- | Encoder for hydra.core.EitherType+eitherType :: Core.EitherType -> Core.Term+eitherType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.EitherType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (type_ (Core.eitherTypeLeft x))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (type_ (Core.eitherTypeRight x))}]})+-- | Encoder for hydra.core.Field+field :: Core.Field -> Core.Term+field x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Field"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (name (Core.fieldName x))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (term (Core.fieldTerm x))}]})+-- | Encoder for hydra.core.FieldType+fieldType :: Core.FieldType -> Core.Term+fieldType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FieldType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (name (Core.fieldTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (type_ (Core.fieldTypeType x))}]})+-- | Encoder for hydra.core.FloatType+floatType :: Core.FloatType -> Core.Term+floatType x =+    case x of+      Core.FloatTypeFloat32 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "float32"),+          Core.fieldTerm = Core.TermUnit}})+      Core.FloatTypeFloat64 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "float64"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.core.FloatValue+floatValue :: Core.FloatValue -> Core.Term+floatValue x =+    case x of+      Core.FloatValueFloat32 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "float32"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 v0)))}})+      Core.FloatValueFloat64 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "float64"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 v0)))}})+-- | Encoder for hydra.core.ForallType+forallType :: Core.ForallType -> Core.Term+forallType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.ForallType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (name (Core.forallTypeParameter x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (type_ (Core.forallTypeBody x))}]})+-- | Encoder for hydra.core.FunctionType+functionType :: Core.FunctionType -> Core.Term+functionType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.FunctionType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (type_ (Core.functionTypeDomain x))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = (type_ (Core.functionTypeCodomain x))}]})+-- | Encoder for hydra.core.Injection+injection :: Core.Injection -> Core.Term+injection x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Injection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (name (Core.injectionTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = (field (Core.injectionField x))}]})+-- | Encoder for hydra.core.IntegerType+integerType :: Core.IntegerType -> Core.Term+integerType x =+    case x of+      Core.IntegerTypeBigint -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "bigint"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeInt8 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int8"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeInt16 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int16"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeInt32 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int32"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeInt64 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int64"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeUint8 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint8"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeUint16 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint16"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeUint32 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint32"),+          Core.fieldTerm = Core.TermUnit}})+      Core.IntegerTypeUint64 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint64"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.core.IntegerValue+integerValue :: Core.IntegerValue -> Core.Term+integerValue x =+    case x of+      Core.IntegerValueBigint v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "bigint"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueBigint v0)))}})+      Core.IntegerValueInt8 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int8"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt8 v0)))}})+      Core.IntegerValueInt16 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int16"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt16 v0)))}})+      Core.IntegerValueInt32 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int32"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Core.IntegerValueInt64 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "int64"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 v0)))}})+      Core.IntegerValueUint8 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint8"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint8 v0)))}})+      Core.IntegerValueUint16 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint16"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint16 v0)))}})+      Core.IntegerValueUint32 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint32"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 v0)))}})+      Core.IntegerValueUint64 v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "uint64"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint64 v0)))}})+-- | Encoder for hydra.core.Lambda+lambda :: Core.Lambda -> Core.Term+lambda x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Lambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (name (Core.lambdaParameter x))},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map type_ opt)) (Core.lambdaDomain x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (term (Core.lambdaBody x))}]})+-- | Encoder for hydra.core.Let+let_ :: Core.Let -> Core.Term+let_ x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Let"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map binding xs)) (Core.letBindings x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (term (Core.letBody x))}]})+-- | Encoder for hydra.core.Literal+literal :: Core.Literal -> Core.Term+literal x =+    case x of+      Core.LiteralBinary v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "binary"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralBinary v0))}})+      Core.LiteralBoolean v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "boolean"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralBoolean v0))}})+      Core.LiteralDecimal v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "decimal"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralDecimal v0))}})+      Core.LiteralFloat v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "float"),+          Core.fieldTerm = (floatValue v0)}})+      Core.LiteralInteger v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "integer"),+          Core.fieldTerm = (integerValue v0)}})+      Core.LiteralString v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "string"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}})+-- | Encoder for hydra.core.LiteralType+literalType :: Core.LiteralType -> Core.Term+literalType x =+    case x of+      Core.LiteralTypeBinary -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "binary"),+          Core.fieldTerm = Core.TermUnit}})+      Core.LiteralTypeBoolean -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "boolean"),+          Core.fieldTerm = Core.TermUnit}})+      Core.LiteralTypeDecimal -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "decimal"),+          Core.fieldTerm = Core.TermUnit}})+      Core.LiteralTypeFloat v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "float"),+          Core.fieldTerm = (floatType v0)}})+      Core.LiteralTypeInteger v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "integer"),+          Core.fieldTerm = (integerType v0)}})+      Core.LiteralTypeString -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "string"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.core.MapType+mapType :: Core.MapType -> Core.Term+mapType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.MapType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = (type_ (Core.mapTypeKeys x))},+        Core.Field {+          Core.fieldName = (Core.Name "values"),+          Core.fieldTerm = (type_ (Core.mapTypeValues x))}]})+-- | Encoder for hydra.core.Name+name :: Core.Name -> Core.Term+name x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Core.unName x))})+-- | Encoder for hydra.core.PairType+pairType :: Core.PairType -> Core.Term+pairType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.PairType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "first"),+          Core.fieldTerm = (type_ (Core.pairTypeFirst x))},+        Core.Field {+          Core.fieldName = (Core.Name "second"),+          Core.fieldTerm = (type_ (Core.pairTypeSecond x))}]})+-- | Encoder for hydra.core.Projection+projection :: Core.Projection -> Core.Term+projection x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Projection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (name (Core.projectionTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (name (Core.projectionFieldName x))}]})+-- | Encoder for hydra.core.Record+record :: Core.Record -> Core.Term+record x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Record"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (name (Core.recordTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "fields"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map field xs)) (Core.recordFields x))}]})+-- | Encoder for hydra.core.Term+term :: Core.Term -> Core.Term+term x =+    case x of+      Core.TermAnnotated v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "annotated"),+          Core.fieldTerm = (annotatedTerm v0)}})+      Core.TermApplication v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "application"),+          Core.fieldTerm = (application v0)}})+      Core.TermCases v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = (caseStatement v0)}})+      Core.TermEither v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "either"),+          Core.fieldTerm = (Core.TermEither (Eithers.bimap term term v0))}})+      Core.TermInject v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "inject"),+          Core.fieldTerm = (injection v0)}})+      Core.TermLambda v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lambda"),+          Core.fieldTerm = (lambda v0)}})+      Core.TermLet v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "let"),+          Core.fieldTerm = (let_ v0)}})+      Core.TermList v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "list"),+          Core.fieldTerm = (Core.TermList (Lists.map term v0))}})+      Core.TermLiteral v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "literal"),+          Core.fieldTerm = (literal v0)}})+      Core.TermMap v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "map"),+          Core.fieldTerm = (Core.TermMap (Maps.bimap term term v0))}})+      Core.TermOptional v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "optional"),+          Core.fieldTerm = (Core.TermOptional (Optionals.map term v0))}})+      Core.TermPair v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pair"),+          Core.fieldTerm = (Core.TermPair (Pairs.bimap term term v0))}})+      Core.TermProject v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "project"),+          Core.fieldTerm = (projection v0)}})+      Core.TermRecord v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "record"),+          Core.fieldTerm = (record v0)}})+      Core.TermSet v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "set"),+          Core.fieldTerm = (Core.TermSet (Sets.map term v0))}})+      Core.TermTypeApplication v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeApplication"),+          Core.fieldTerm = (typeApplicationTerm v0)}})+      Core.TermTypeLambda v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeLambda"),+          Core.fieldTerm = (typeLambda v0)}})+      Core.TermUnit -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unit"),+          Core.fieldTerm = Core.TermUnit}})+      Core.TermUnwrap v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unwrap"),+          Core.fieldTerm = (name v0)}})+      Core.TermVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (name v0)}})+      Core.TermWrap v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wrap"),+          Core.fieldTerm = (wrappedTerm v0)}})+-- | Encoder for hydra.core.Type+type_ :: Core.Type -> Core.Term+type_ x =+    case x of+      Core.TypeAnnotated v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "annotated"),+          Core.fieldTerm = (annotatedType v0)}})+      Core.TypeApplication v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "application"),+          Core.fieldTerm = (applicationType v0)}})+      Core.TypeEither v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "either"),+          Core.fieldTerm = (eitherType v0)}})+      Core.TypeForall v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "forall"),+          Core.fieldTerm = (forallType v0)}})+      Core.TypeFunction v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = (functionType v0)}})+      Core.TypeList v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "list"),+          Core.fieldTerm = (type_ v0)}})+      Core.TypeLiteral v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "literal"),+          Core.fieldTerm = (literalType v0)}})+      Core.TypeMap v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "map"),+          Core.fieldTerm = (mapType v0)}})+      Core.TypeOptional v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "optional"),+          Core.fieldTerm = (type_ v0)}})+      Core.TypePair v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pair"),+          Core.fieldTerm = (pairType v0)}})+      Core.TypeRecord v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "record"),+          Core.fieldTerm = (Core.TermList (Lists.map fieldType v0))}})+      Core.TypeSet v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "set"),+          Core.fieldTerm = (type_ v0)}})+      Core.TypeUnion v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "union"),+          Core.fieldTerm = (Core.TermList (Lists.map fieldType v0))}})+      Core.TypeUnit -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unit"),+          Core.fieldTerm = Core.TermUnit}})+      Core.TypeVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (name v0)}})+      Core.TypeVoid -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "void"),+          Core.fieldTerm = Core.TermUnit}})+      Core.TypeWrap v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Type"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wrap"),+          Core.fieldTerm = (type_ v0)}})+-- | Encoder for hydra.core.TypeApplicationTerm+typeApplicationTerm :: Core.TypeApplicationTerm -> Core.Term+typeApplicationTerm x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (term (Core.typeApplicationTermBody x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (type_ (Core.typeApplicationTermType x))}]})+-- | Encoder for hydra.core.TypeClassConstraint+typeClassConstraint :: Core.TypeClassConstraint -> Core.Term+typeClassConstraint x =+    case x of+      Core.TypeClassConstraintSimple v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.TypeClassConstraint"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "simple"),+          Core.fieldTerm = (name v0)}})+-- | Encoder for hydra.core.TypeLambda+typeLambda :: Core.TypeLambda -> Core.Term+typeLambda x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "parameter"),+          Core.fieldTerm = (name (Core.typeLambdaParameter x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (term (Core.typeLambdaBody x))}]})+-- | Encoder for hydra.core.TypeScheme+typeScheme :: Core.TypeScheme -> Core.Term+typeScheme x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map name xs)) (Core.typeSchemeVariables x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (type_ (Core.typeSchemeBody x))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\m -> Core.TermMap (Maps.bimap name typeVariableConstraints m)) opt)) (Core.typeSchemeConstraints x))}]})+-- | Encoder for hydra.core.TypeVariableConstraints+typeVariableConstraints :: Core.TypeVariableConstraints -> Core.Term+typeVariableConstraints x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.TypeVariableConstraints"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "classes"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map typeClassConstraint xs)) (Core.typeVariableConstraintsClasses x))}]})+-- | Encoder for hydra.core.WrappedTerm+wrappedTerm :: Core.WrappedTerm -> Core.Term+wrappedTerm x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (name (Core.wrappedTermTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (term (Core.wrappedTermBody x))}]})
+ src/main/haskell/Hydra/Encode/Error/Checking.hs view
@@ -0,0 +1,227 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.error.checking++module Hydra.Encode.Error.Checking where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Paths as Paths+import qualified Hydra.Encode.Typing as Typing+import qualified Hydra.Encode.Variants as Variants+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Sets as Sets+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.error.checking.CheckingError+checkingError :: Checking.CheckingError -> Core.Term+checkingError x =+    case x of+      Checking.CheckingErrorIncorrectUnification v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "incorrectUnification"),+          Core.fieldTerm = (incorrectUnificationError v0)}})+      Checking.CheckingErrorNotAForallType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "notAForallType"),+          Core.fieldTerm = (notAForallTypeError v0)}})+      Checking.CheckingErrorNotAFunctionType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "notAFunctionType"),+          Core.fieldTerm = (notAFunctionTypeError v0)}})+      Checking.CheckingErrorOther v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "other"),+          Core.fieldTerm = (otherCheckingError v0)}})+      Checking.CheckingErrorTypeArityMismatch v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeArityMismatch"),+          Core.fieldTerm = (typeArityMismatchError v0)}})+      Checking.CheckingErrorTypeMismatch v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeMismatch"),+          Core.fieldTerm = (typeMismatchError v0)}})+      Checking.CheckingErrorUnboundTypeVariables v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unboundTypeVariables"),+          Core.fieldTerm = (unboundTypeVariablesError v0)}})+      Checking.CheckingErrorUndefinedTermVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedTermVariable"),+          Core.fieldTerm = (undefinedTermVariableCheckingError v0)}})+      Checking.CheckingErrorUnequalTypes v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unequalTypes"),+          Core.fieldTerm = (unequalTypesError v0)}})+      Checking.CheckingErrorUnsupportedTermVariant v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unsupportedTermVariant"),+          Core.fieldTerm = (unsupportedTermVariantError v0)}})+      Checking.CheckingErrorUntypedLambda v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "untypedLambda"),+          Core.fieldTerm = (untypedLambdaError v0)}})+      Checking.CheckingErrorUntypedLetBinding v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "untypedLetBinding"),+          Core.fieldTerm = (untypedLetBindingError v0)}})+      Checking.CheckingErrorUntypedTermVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "untypedTermVariable"),+          Core.fieldTerm = (untypedTermVariableCheckingError v0)}})+-- | Encoder for hydra.error.checking.IncorrectUnificationError+incorrectUnificationError :: Checking.IncorrectUnificationError -> Core.Term+incorrectUnificationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "substitution"),+          Core.fieldTerm = (Typing.typeSubst (Checking.incorrectUnificationErrorSubstitution x))}]})+-- | Encoder for hydra.error.checking.NotAForallTypeError+notAForallTypeError :: Checking.NotAForallTypeError -> Core.Term+notAForallTypeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Checking.notAForallTypeErrorType x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Checking.notAForallTypeErrorTypeArguments x))}]})+-- | Encoder for hydra.error.checking.NotAFunctionTypeError+notAFunctionTypeError :: Checking.NotAFunctionTypeError -> Core.Term+notAFunctionTypeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Checking.notAFunctionTypeErrorType x))}]})+-- | Encoder for hydra.error.checking.OtherCheckingError+otherCheckingError :: Checking.OtherCheckingError -> Core.Term+otherCheckingError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Paths.subtermPath (Checking.otherCheckingErrorPath x))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Checking.otherCheckingErrorMessage x))}]})+-- | Encoder for hydra.error.checking.TypeArityMismatchError+typeArityMismatchError :: Checking.TypeArityMismatchError -> Core.Term+typeArityMismatchError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Checking.typeArityMismatchErrorType x))},+        Core.Field {+          Core.fieldName = (Core.Name "expectedArity"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Checking.typeArityMismatchErrorExpectedArity x))},+        Core.Field {+          Core.fieldName = (Core.Name "actualArity"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Checking.typeArityMismatchErrorActualArity x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeArguments"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Checking.typeArityMismatchErrorTypeArguments x))}]})+-- | Encoder for hydra.error.checking.TypeMismatchError+typeMismatchError :: Checking.TypeMismatchError -> Core.Term+typeMismatchError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (EncodeCore.type_ (Checking.typeMismatchErrorExpectedType x))},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (EncodeCore.type_ (Checking.typeMismatchErrorActualType x))}]})+-- | Encoder for hydra.error.checking.UnboundTypeVariablesError+unboundTypeVariablesError :: Checking.UnboundTypeVariablesError -> Core.Term+unboundTypeVariablesError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = ((\s -> Core.TermSet (Sets.map EncodeCore.name s)) (Checking.unboundTypeVariablesErrorVariables x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Checking.unboundTypeVariablesErrorType x))}]})+-- | Encoder for hydra.error.checking.UndefinedTermVariableCheckingError+undefinedTermVariableCheckingError :: Checking.UndefinedTermVariableCheckingError -> Core.Term+undefinedTermVariableCheckingError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Paths.subtermPath (Checking.undefinedTermVariableCheckingErrorPath x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Checking.undefinedTermVariableCheckingErrorName x))}]})+-- | Encoder for hydra.error.checking.UnequalTypesError+unequalTypesError :: Checking.UnequalTypesError -> Core.Term+unequalTypesError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "types"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Checking.unequalTypesErrorTypes x))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Checking.unequalTypesErrorDescription x))}]})+-- | Encoder for hydra.error.checking.UnsupportedTermVariantError+unsupportedTermVariantError :: Checking.UnsupportedTermVariantError -> Core.Term+unsupportedTermVariantError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "termVariant"),+          Core.fieldTerm = (Variants.termVariant (Checking.unsupportedTermVariantErrorTermVariant x))}]})+-- | Encoder for hydra.error.checking.UntypedLambdaError+untypedLambdaError :: t0 -> Core.Term+untypedLambdaError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"),+      Core.recordFields = []})+-- | Encoder for hydra.error.checking.UntypedLetBindingError+untypedLetBindingError :: Checking.UntypedLetBindingError -> Core.Term+untypedLetBindingError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "binding"),+          Core.fieldTerm = (EncodeCore.binding (Checking.untypedLetBindingErrorBinding x))}]})+-- | Encoder for hydra.error.checking.UntypedTermVariableCheckingError+untypedTermVariableCheckingError :: Checking.UntypedTermVariableCheckingError -> Core.Term+untypedTermVariableCheckingError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Paths.subtermPath (Checking.untypedTermVariableCheckingErrorPath x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Checking.untypedTermVariableCheckingErrorName x))}]})
+ src/main/haskell/Hydra/Encode/Error/Core.hs view
@@ -0,0 +1,658 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.error.core++module Hydra.Encode.Error.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Paths as Paths+import qualified Hydra.Encode.Variants as Variants+import qualified Hydra.Error.Core as ErrorCore+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.error.core.ConstantConditionError+constantConditionError :: ErrorCore.ConstantConditionError -> Core.Term+constantConditionError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.constantConditionErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (ErrorCore.constantConditionErrorValue x))}]})+-- | Encoder for hydra.error.core.DuplicateBindingError+duplicateBindingError :: ErrorCore.DuplicateBindingError -> Core.Term+duplicateBindingError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.duplicateBindingErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.duplicateBindingErrorName x))}]})+-- | Encoder for hydra.error.core.DuplicateFieldError+duplicateFieldError :: ErrorCore.DuplicateFieldError -> Core.Term+duplicateFieldError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.duplicateFieldErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.duplicateFieldErrorName x))}]})+-- | Encoder for hydra.error.core.DuplicateRecordTypeFieldNamesError+duplicateRecordTypeFieldNamesError :: ErrorCore.DuplicateRecordTypeFieldNamesError -> Core.Term+duplicateRecordTypeFieldNamesError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.duplicateRecordTypeFieldNamesErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.duplicateRecordTypeFieldNamesErrorName x))}]})+-- | Encoder for hydra.error.core.DuplicateUnionTypeFieldNamesError+duplicateUnionTypeFieldNamesError :: ErrorCore.DuplicateUnionTypeFieldNamesError -> Core.Term+duplicateUnionTypeFieldNamesError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.duplicateUnionTypeFieldNamesErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.duplicateUnionTypeFieldNamesErrorName x))}]})+-- | Encoder for hydra.error.core.EmptyCaseStatementError+emptyCaseStatementError :: ErrorCore.EmptyCaseStatementError -> Core.Term+emptyCaseStatementError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.emptyCaseStatementErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.emptyCaseStatementErrorTypeName x))}]})+-- | Encoder for hydra.error.core.EmptyLetBindingsError+emptyLetBindingsError :: ErrorCore.EmptyLetBindingsError -> Core.Term+emptyLetBindingsError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.emptyLetBindingsErrorLocation x))}]})+-- | Encoder for hydra.error.core.EmptyRecordTypeError+emptyRecordTypeError :: ErrorCore.EmptyRecordTypeError -> Core.Term+emptyRecordTypeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.emptyRecordTypeErrorLocation x))}]})+-- | Encoder for hydra.error.core.EmptyTermAnnotationError+emptyTermAnnotationError :: ErrorCore.EmptyTermAnnotationError -> Core.Term+emptyTermAnnotationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.emptyTermAnnotationErrorLocation x))}]})+-- | Encoder for hydra.error.core.EmptyTypeAnnotationError+emptyTypeAnnotationError :: ErrorCore.EmptyTypeAnnotationError -> Core.Term+emptyTypeAnnotationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.emptyTypeAnnotationErrorLocation x))}]})+-- | Encoder for hydra.error.core.EmptyTypeNameInTermError+emptyTypeNameInTermError :: ErrorCore.EmptyTypeNameInTermError -> Core.Term+emptyTypeNameInTermError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.emptyTypeNameInTermErrorLocation x))}]})+-- | Encoder for hydra.error.core.EmptyUnionTypeError+emptyUnionTypeError :: ErrorCore.EmptyUnionTypeError -> Core.Term+emptyUnionTypeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.emptyUnionTypeErrorLocation x))}]})+-- | Encoder for hydra.error.core.InvalidForallParameterNameError+invalidForallParameterNameError :: ErrorCore.InvalidForallParameterNameError -> Core.Term+invalidForallParameterNameError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.invalidForallParameterNameErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.invalidForallParameterNameErrorName x))}]})+-- | Encoder for hydra.error.core.InvalidLambdaParameterNameError+invalidLambdaParameterNameError :: ErrorCore.InvalidLambdaParameterNameError -> Core.Term+invalidLambdaParameterNameError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.invalidLambdaParameterNameErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.invalidLambdaParameterNameErrorName x))}]})+-- | Encoder for hydra.error.core.InvalidLetBindingNameError+invalidLetBindingNameError :: ErrorCore.InvalidLetBindingNameError -> Core.Term+invalidLetBindingNameError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.invalidLetBindingNameErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.invalidLetBindingNameErrorName x))}]})+-- | Encoder for hydra.error.core.InvalidLiteralError+invalidLiteralError :: ErrorCore.InvalidLiteralError -> Core.Term+invalidLiteralError x =+    case x of+      ErrorCore.InvalidLiteralErrorTypeMismatch v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidLiteralError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeMismatch"),+          Core.fieldTerm = (literalTypeMismatchError v0)}})+-- | Encoder for hydra.error.core.InvalidTermError+invalidTermError :: ErrorCore.InvalidTermError -> Core.Term+invalidTermError x =+    case x of+      ErrorCore.InvalidTermErrorConstantCondition v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "constantCondition"),+          Core.fieldTerm = (constantConditionError v0)}})+      ErrorCore.InvalidTermErrorDuplicateBinding v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "duplicateBinding"),+          Core.fieldTerm = (duplicateBindingError v0)}})+      ErrorCore.InvalidTermErrorDuplicateField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "duplicateField"),+          Core.fieldTerm = (duplicateFieldError v0)}})+      ErrorCore.InvalidTermErrorEmptyCaseStatement v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyCaseStatement"),+          Core.fieldTerm = (emptyCaseStatementError v0)}})+      ErrorCore.InvalidTermErrorEmptyLetBindings v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyLetBindings"),+          Core.fieldTerm = (emptyLetBindingsError v0)}})+      ErrorCore.InvalidTermErrorEmptyTermAnnotation v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyTermAnnotation"),+          Core.fieldTerm = (emptyTermAnnotationError v0)}})+      ErrorCore.InvalidTermErrorEmptyTypeNameInTerm v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyTypeNameInTerm"),+          Core.fieldTerm = (emptyTypeNameInTermError v0)}})+      ErrorCore.InvalidTermErrorInvalidLambdaParameterName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "invalidLambdaParameterName"),+          Core.fieldTerm = (invalidLambdaParameterNameError v0)}})+      ErrorCore.InvalidTermErrorInvalidLetBindingName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "invalidLetBindingName"),+          Core.fieldTerm = (invalidLetBindingNameError v0)}})+      ErrorCore.InvalidTermErrorInvalidTypeLambdaParameterName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"),+          Core.fieldTerm = (invalidTypeLambdaParameterNameError v0)}})+      ErrorCore.InvalidTermErrorNestedTermAnnotation v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nestedTermAnnotation"),+          Core.fieldTerm = (nestedTermAnnotationError v0)}})+      ErrorCore.InvalidTermErrorRedundantWrapUnwrap v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "redundantWrapUnwrap"),+          Core.fieldTerm = (redundantWrapUnwrapError v0)}})+      ErrorCore.InvalidTermErrorSelfApplication v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "selfApplication"),+          Core.fieldTerm = (selfApplicationError v0)}})+      ErrorCore.InvalidTermErrorTermVariableShadowing v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "termVariableShadowing"),+          Core.fieldTerm = (termVariableShadowingError v0)}})+      ErrorCore.InvalidTermErrorTypeVariableShadowingInTypeLambda v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeVariableShadowingInTypeLambda"),+          Core.fieldTerm = (typeVariableShadowingInTypeLambdaError v0)}})+      ErrorCore.InvalidTermErrorUndefinedTermVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedTermVariable"),+          Core.fieldTerm = (undefinedTermVariableError v0)}})+      ErrorCore.InvalidTermErrorUndefinedTypeVariableInBindingType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedTypeVariableInBindingType"),+          Core.fieldTerm = (undefinedTypeVariableInBindingTypeError v0)}})+      ErrorCore.InvalidTermErrorUndefinedTypeVariableInLambdaDomain v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedTypeVariableInLambdaDomain"),+          Core.fieldTerm = (undefinedTypeVariableInLambdaDomainError v0)}})+      ErrorCore.InvalidTermErrorUndefinedTypeVariableInTypeApplication v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"),+          Core.fieldTerm = (undefinedTypeVariableInTypeApplicationError v0)}})+      ErrorCore.InvalidTermErrorUnknownPrimitiveName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unknownPrimitiveName"),+          Core.fieldTerm = (unknownPrimitiveNameError v0)}})+      ErrorCore.InvalidTermErrorUnnecessaryIdentityApplication v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unnecessaryIdentityApplication"),+          Core.fieldTerm = (unnecessaryIdentityApplicationError v0)}})+      ErrorCore.InvalidTermErrorUntypedTermVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "untypedTermVariable"),+          Core.fieldTerm = (untypedTermVariableError v0)}})+-- | Encoder for hydra.error.core.InvalidTypeError+invalidTypeError :: ErrorCore.InvalidTypeError -> Core.Term+invalidTypeError x =+    case x of+      ErrorCore.InvalidTypeErrorDuplicateRecordTypeFieldNames v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "duplicateRecordTypeFieldNames"),+          Core.fieldTerm = (duplicateRecordTypeFieldNamesError v0)}})+      ErrorCore.InvalidTypeErrorDuplicateUnionTypeFieldNames v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "duplicateUnionTypeFieldNames"),+          Core.fieldTerm = (duplicateUnionTypeFieldNamesError v0)}})+      ErrorCore.InvalidTypeErrorEmptyRecordType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyRecordType"),+          Core.fieldTerm = (emptyRecordTypeError v0)}})+      ErrorCore.InvalidTypeErrorEmptyTypeAnnotation v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyTypeAnnotation"),+          Core.fieldTerm = (emptyTypeAnnotationError v0)}})+      ErrorCore.InvalidTypeErrorEmptyUnionType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyUnionType"),+          Core.fieldTerm = (emptyUnionTypeError v0)}})+      ErrorCore.InvalidTypeErrorInvalidForallParameterName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "invalidForallParameterName"),+          Core.fieldTerm = (invalidForallParameterNameError v0)}})+      ErrorCore.InvalidTypeErrorInvalidTypeSchemeVariableName v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "invalidTypeSchemeVariableName"),+          Core.fieldTerm = (invalidTypeSchemeVariableNameError v0)}})+      ErrorCore.InvalidTypeErrorNestedTypeAnnotation v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nestedTypeAnnotation"),+          Core.fieldTerm = (nestedTypeAnnotationError v0)}})+      ErrorCore.InvalidTypeErrorNonComparableMapKeyType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nonComparableMapKeyType"),+          Core.fieldTerm = (nonComparableMapKeyTypeError v0)}})+      ErrorCore.InvalidTypeErrorNonComparableSetElementType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "nonComparableSetElementType"),+          Core.fieldTerm = (nonComparableSetElementTypeError v0)}})+      ErrorCore.InvalidTypeErrorSingleVariantUnion v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "singleVariantUnion"),+          Core.fieldTerm = (singleVariantUnionError v0)}})+      ErrorCore.InvalidTypeErrorTypeVariableShadowingInForall v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeVariableShadowingInForall"),+          Core.fieldTerm = (typeVariableShadowingInForallError v0)}})+      ErrorCore.InvalidTypeErrorUndefinedTypeVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedTypeVariable"),+          Core.fieldTerm = (undefinedTypeVariableError v0)}})+      ErrorCore.InvalidTypeErrorVoidInNonBottomPosition v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "voidInNonBottomPosition"),+          Core.fieldTerm = (voidInNonBottomPositionError v0)}})+-- | Encoder for hydra.error.core.InvalidTypeLambdaParameterNameError+invalidTypeLambdaParameterNameError :: ErrorCore.InvalidTypeLambdaParameterNameError -> Core.Term+invalidTypeLambdaParameterNameError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.invalidTypeLambdaParameterNameErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.invalidTypeLambdaParameterNameErrorName x))}]})+-- | Encoder for hydra.error.core.InvalidTypeSchemeVariableNameError+invalidTypeSchemeVariableNameError :: ErrorCore.InvalidTypeSchemeVariableNameError -> Core.Term+invalidTypeSchemeVariableNameError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.invalidTypeSchemeVariableNameErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.invalidTypeSchemeVariableNameErrorName x))}]})+-- | Encoder for hydra.error.core.LiteralTypeMismatchError+literalTypeMismatchError :: ErrorCore.LiteralTypeMismatchError -> Core.Term+literalTypeMismatchError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedType"),+          Core.fieldTerm = (EncodeCore.literalType (ErrorCore.literalTypeMismatchErrorExpectedType x))},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (EncodeCore.literalType (ErrorCore.literalTypeMismatchErrorActualType x))}]})+-- | Encoder for hydra.error.core.NestedTermAnnotationError+nestedTermAnnotationError :: ErrorCore.NestedTermAnnotationError -> Core.Term+nestedTermAnnotationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.nestedTermAnnotationErrorLocation x))}]})+-- | Encoder for hydra.error.core.NestedTypeAnnotationError+nestedTypeAnnotationError :: ErrorCore.NestedTypeAnnotationError -> Core.Term+nestedTypeAnnotationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.nestedTypeAnnotationErrorLocation x))}]})+-- | Encoder for hydra.error.core.NonComparableMapKeyTypeError+nonComparableMapKeyTypeError :: ErrorCore.NonComparableMapKeyTypeError -> Core.Term+nonComparableMapKeyTypeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.nonComparableMapKeyTypeErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "keyType"),+          Core.fieldTerm = (EncodeCore.type_ (ErrorCore.nonComparableMapKeyTypeErrorKeyType x))}]})+-- | Encoder for hydra.error.core.NonComparableSetElementTypeError+nonComparableSetElementTypeError :: ErrorCore.NonComparableSetElementTypeError -> Core.Term+nonComparableSetElementTypeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.nonComparableSetElementTypeErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "elementType"),+          Core.fieldTerm = (EncodeCore.type_ (ErrorCore.nonComparableSetElementTypeErrorElementType x))}]})+-- | Encoder for hydra.error.core.RedundantWrapUnwrapError+redundantWrapUnwrapError :: ErrorCore.RedundantWrapUnwrapError -> Core.Term+redundantWrapUnwrapError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.redundantWrapUnwrapErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.redundantWrapUnwrapErrorTypeName x))}]})+-- | Encoder for hydra.error.core.SelfApplicationError+selfApplicationError :: ErrorCore.SelfApplicationError -> Core.Term+selfApplicationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.selfApplicationErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.selfApplicationErrorName x))}]})+-- | Encoder for hydra.error.core.SingleVariantUnionError+singleVariantUnionError :: ErrorCore.SingleVariantUnionError -> Core.Term+singleVariantUnionError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.singleVariantUnionErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.singleVariantUnionErrorFieldName x))}]})+-- | Encoder for hydra.error.core.TermVariableShadowingError+termVariableShadowingError :: ErrorCore.TermVariableShadowingError -> Core.Term+termVariableShadowingError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.termVariableShadowingErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.termVariableShadowingErrorName x))}]})+-- | Encoder for hydra.error.core.TypeVariableShadowingInForallError+typeVariableShadowingInForallError :: ErrorCore.TypeVariableShadowingInForallError -> Core.Term+typeVariableShadowingInForallError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.typeVariableShadowingInForallErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.typeVariableShadowingInForallErrorName x))}]})+-- | Encoder for hydra.error.core.TypeVariableShadowingInTypeLambdaError+typeVariableShadowingInTypeLambdaError :: ErrorCore.TypeVariableShadowingInTypeLambdaError -> Core.Term+typeVariableShadowingInTypeLambdaError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.typeVariableShadowingInTypeLambdaErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.typeVariableShadowingInTypeLambdaErrorName x))}]})+-- | Encoder for hydra.error.core.UndefinedFieldError+undefinedFieldError :: ErrorCore.UndefinedFieldError -> Core.Term+undefinedFieldError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.undefinedFieldErrorFieldName x))},+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.undefinedFieldErrorTypeName x))}]})+-- | Encoder for hydra.error.core.UndefinedTermVariableError+undefinedTermVariableError :: ErrorCore.UndefinedTermVariableError -> Core.Term+undefinedTermVariableError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.undefinedTermVariableErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.undefinedTermVariableErrorName x))}]})+-- | Encoder for hydra.error.core.UndefinedTypeVariableError+undefinedTypeVariableError :: ErrorCore.UndefinedTypeVariableError -> Core.Term+undefinedTypeVariableError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.undefinedTypeVariableErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.undefinedTypeVariableErrorName x))}]})+-- | Encoder for hydra.error.core.UndefinedTypeVariableInBindingTypeError+undefinedTypeVariableInBindingTypeError :: ErrorCore.UndefinedTypeVariableInBindingTypeError -> Core.Term+undefinedTypeVariableInBindingTypeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.undefinedTypeVariableInBindingTypeErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.undefinedTypeVariableInBindingTypeErrorName x))}]})+-- | Encoder for hydra.error.core.UndefinedTypeVariableInLambdaDomainError+undefinedTypeVariableInLambdaDomainError :: ErrorCore.UndefinedTypeVariableInLambdaDomainError -> Core.Term+undefinedTypeVariableInLambdaDomainError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.undefinedTypeVariableInLambdaDomainErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.undefinedTypeVariableInLambdaDomainErrorName x))}]})+-- | Encoder for hydra.error.core.UndefinedTypeVariableInTypeApplicationError+undefinedTypeVariableInTypeApplicationError :: ErrorCore.UndefinedTypeVariableInTypeApplicationError -> Core.Term+undefinedTypeVariableInTypeApplicationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.undefinedTypeVariableInTypeApplicationErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.undefinedTypeVariableInTypeApplicationErrorName x))}]})+-- | Encoder for hydra.error.core.UnexpectedTermVariantError+unexpectedTermVariantError :: ErrorCore.UnexpectedTermVariantError -> Core.Term+unexpectedTermVariantError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Variants.termVariant (ErrorCore.unexpectedTermVariantErrorExpectedVariant x))},+        Core.Field {+          Core.fieldName = (Core.Name "actualTerm"),+          Core.fieldTerm = (EncodeCore.term (ErrorCore.unexpectedTermVariantErrorActualTerm x))}]})+-- | Encoder for hydra.error.core.UnexpectedTypeVariantError+unexpectedTypeVariantError :: ErrorCore.UnexpectedTypeVariantError -> Core.Term+unexpectedTypeVariantError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expectedVariant"),+          Core.fieldTerm = (Variants.typeVariant (ErrorCore.unexpectedTypeVariantErrorExpectedVariant x))},+        Core.Field {+          Core.fieldName = (Core.Name "actualType"),+          Core.fieldTerm = (EncodeCore.type_ (ErrorCore.unexpectedTypeVariantErrorActualType x))}]})+-- | Encoder for hydra.error.core.UnknownPrimitiveNameError+unknownPrimitiveNameError :: ErrorCore.UnknownPrimitiveNameError -> Core.Term+unknownPrimitiveNameError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.unknownPrimitiveNameErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.unknownPrimitiveNameErrorName x))}]})+-- | Encoder for hydra.error.core.UnnecessaryIdentityApplicationError+unnecessaryIdentityApplicationError :: ErrorCore.UnnecessaryIdentityApplicationError -> Core.Term+unnecessaryIdentityApplicationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.unnecessaryIdentityApplicationErrorLocation x))}]})+-- | Encoder for hydra.error.core.UntypedTermVariableError+untypedTermVariableError :: ErrorCore.UntypedTermVariableError -> Core.Term+untypedTermVariableError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.untypedTermVariableErrorLocation x))},+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (ErrorCore.untypedTermVariableErrorName x))}]})+-- | Encoder for hydra.error.core.VoidInNonBottomPositionError+voidInNonBottomPositionError :: ErrorCore.VoidInNonBottomPositionError -> Core.Term+voidInNonBottomPositionError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "location"),+          Core.fieldTerm = (Paths.subtermPath (ErrorCore.voidInNonBottomPositionErrorLocation x))}]})
+ src/main/haskell/Hydra/Encode/Errors.hs view
@@ -0,0 +1,300 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.errors++module Hydra.Encode.Errors where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Error.Checking as Checking+import qualified Hydra.Encode.Error.Core as ErrorCore+import qualified Hydra.Encode.Paths as Paths+import qualified Hydra.Encode.Typing as Typing+import qualified Hydra.Encode.Variants as Variants+import qualified Hydra.Errors as Errors+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.errors.DecodingError+decodingError :: Errors.DecodingError -> Core.Term+decodingError x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.unDecodingError x))})+-- | Encoder for hydra.errors.EmptyListError+emptyListError :: t0 -> Core.Term+emptyListError _ = Core.TermUnit+-- | Encoder for hydra.errors.Error+error :: Errors.Error -> Core.Term+error x =+    case x of+      Errors.ErrorChecking v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "checking"),+          Core.fieldTerm = (Checking.checkingError v0)}})+      Errors.ErrorDecoding v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "decoding"),+          Core.fieldTerm = (decodingError v0)}})+      Errors.ErrorDuplicateBinding v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "duplicateBinding"),+          Core.fieldTerm = (ErrorCore.duplicateBindingError v0)}})+      Errors.ErrorDuplicateField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "duplicateField"),+          Core.fieldTerm = (ErrorCore.duplicateFieldError v0)}})+      Errors.ErrorExtraction v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "extraction"),+          Core.fieldTerm = (extractionError v0)}})+      Errors.ErrorInference v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "inference"),+          Core.fieldTerm = (inferenceError v0)}})+      Errors.ErrorInvalidLiteral v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "invalidLiteral"),+          Core.fieldTerm = (ErrorCore.invalidLiteralError v0)}})+      Errors.ErrorOther v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "other"),+          Core.fieldTerm = (otherError v0)}})+      Errors.ErrorResolution v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "resolution"),+          Core.fieldTerm = (resolutionError v0)}})+      Errors.ErrorUndefinedField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedField"),+          Core.fieldTerm = (ErrorCore.undefinedFieldError v0)}})+      Errors.ErrorUndefinedTermVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "undefinedTermVariable"),+          Core.fieldTerm = (ErrorCore.undefinedTermVariableError v0)}})+      Errors.ErrorUntypedTermVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "untypedTermVariable"),+          Core.fieldTerm = (ErrorCore.untypedTermVariableError v0)}})+      Errors.ErrorUnexpectedTermVariant v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unexpectedTermVariant"),+          Core.fieldTerm = (ErrorCore.unexpectedTermVariantError v0)}})+      Errors.ErrorUnexpectedTypeVariant v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unexpectedTypeVariant"),+          Core.fieldTerm = (ErrorCore.unexpectedTypeVariantError v0)}})+      Errors.ErrorUnification v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unification"),+          Core.fieldTerm = (unificationError v0)}})+-- | Encoder for hydra.errors.ExtractionError+extractionError :: Errors.ExtractionError -> Core.Term+extractionError x =+    case x of+      Errors.ExtractionErrorEmptyList v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "emptyList"),+          Core.fieldTerm = (emptyListError v0)}})+      Errors.ExtractionErrorMultipleBindings v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "multipleBindings"),+          Core.fieldTerm = (multipleBindingsError v0)}})+      Errors.ExtractionErrorMultipleFields v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "multipleFields"),+          Core.fieldTerm = (multipleFieldsError v0)}})+      Errors.ExtractionErrorNoMatchingField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "noMatchingField"),+          Core.fieldTerm = (noMatchingFieldError v0)}})+      Errors.ExtractionErrorNoSuchBinding v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "noSuchBinding"),+          Core.fieldTerm = (noSuchBindingError v0)}})+      Errors.ExtractionErrorNotEnoughCases v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "notEnoughCases"),+          Core.fieldTerm = (notEnoughCasesError v0)}})+      Errors.ExtractionErrorUnexpectedShape v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unexpectedShape"),+          Core.fieldTerm = (unexpectedShapeError v0)}})+-- | Encoder for hydra.errors.InferenceError+inferenceError :: Errors.InferenceError -> Core.Term+inferenceError x =+    case x of+      Errors.InferenceErrorChecking v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "checking"),+          Core.fieldTerm = (Checking.checkingError v0)}})+      Errors.InferenceErrorOther v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "other"),+          Core.fieldTerm = (otherInferenceError v0)}})+      Errors.InferenceErrorUnification v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unification"),+          Core.fieldTerm = (unificationInferenceError v0)}})+-- | Encoder for hydra.errors.MultipleBindingsError+multipleBindingsError :: Errors.MultipleBindingsError -> Core.Term+multipleBindingsError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.MultipleBindingsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Errors.multipleBindingsErrorName x))}]})+-- | Encoder for hydra.errors.MultipleFieldsError+multipleFieldsError :: Errors.MultipleFieldsError -> Core.Term+multipleFieldsError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.MultipleFieldsError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (EncodeCore.name (Errors.multipleFieldsErrorFieldName x))}]})+-- | Encoder for hydra.errors.NoMatchingFieldError+noMatchingFieldError :: Errors.NoMatchingFieldError -> Core.Term+noMatchingFieldError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "fieldName"),+          Core.fieldTerm = (EncodeCore.name (Errors.noMatchingFieldErrorFieldName x))}]})+-- | Encoder for hydra.errors.NoSuchBindingError+noSuchBindingError :: Errors.NoSuchBindingError -> Core.Term+noSuchBindingError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoSuchBindingError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Errors.noSuchBindingErrorName x))}]})+-- | Encoder for hydra.errors.NoSuchPrimitiveError+noSuchPrimitiveError :: Errors.NoSuchPrimitiveError -> Core.Term+noSuchPrimitiveError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Errors.noSuchPrimitiveErrorName x))}]})+-- | Encoder for hydra.errors.NotEnoughCasesError+notEnoughCasesError :: t0 -> Core.Term+notEnoughCasesError _ = Core.TermUnit+-- | Encoder for hydra.errors.OtherError+otherError :: Errors.OtherError -> Core.Term+otherError x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.unOtherError x))})+-- | Encoder for hydra.errors.OtherInferenceError+otherInferenceError :: Errors.OtherInferenceError -> Core.Term+otherInferenceError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Paths.subtermPath (Errors.otherInferenceErrorPath x))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.otherInferenceErrorMessage x))}]})+-- | Encoder for hydra.errors.OtherResolutionError+otherResolutionError :: Errors.OtherResolutionError -> Core.Term+otherResolutionError x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherResolutionError"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.unOtherResolutionError x))})+-- | Encoder for hydra.errors.ResolutionError+resolutionError :: Errors.ResolutionError -> Core.Term+resolutionError x =+    case x of+      Errors.ResolutionErrorNoSuchBinding v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "noSuchBinding"),+          Core.fieldTerm = (noSuchBindingError v0)}})+      Errors.ResolutionErrorNoSuchPrimitive v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "noSuchPrimitive"),+          Core.fieldTerm = (noSuchPrimitiveError v0)}})+      Errors.ResolutionErrorNoMatchingField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "noMatchingField"),+          Core.fieldTerm = (noMatchingFieldError v0)}})+      Errors.ResolutionErrorOther v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "other"),+          Core.fieldTerm = (otherResolutionError v0)}})+      Errors.ResolutionErrorUnexpectedShape v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unexpectedShape"),+          Core.fieldTerm = (unexpectedShapeError v0)}})+-- | Encoder for hydra.errors.UnexpectedShapeError+unexpectedShapeError :: Errors.UnexpectedShapeError -> Core.Term+unexpectedShapeError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "expected"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.unexpectedShapeErrorExpected x))},+        Core.Field {+          Core.fieldName = (Core.Name "actual"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.unexpectedShapeErrorActual x))}]})+-- | Encoder for hydra.errors.UnificationError+unificationError :: Errors.UnificationError -> Core.Term+unificationError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "leftType"),+          Core.fieldTerm = (EncodeCore.type_ (Errors.unificationErrorLeftType x))},+        Core.Field {+          Core.fieldName = (Core.Name "rightType"),+          Core.fieldTerm = (EncodeCore.type_ (Errors.unificationErrorRightType x))},+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Errors.unificationErrorMessage x))}]})+-- | Encoder for hydra.errors.UnificationInferenceError+unificationInferenceError :: Errors.UnificationInferenceError -> Core.Term+unificationInferenceError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (Paths.subtermPath (Errors.unificationInferenceErrorPath x))},+        Core.Field {+          Core.fieldName = (Core.Name "cause"),+          Core.fieldTerm = (unificationError (Errors.unificationInferenceErrorCause x))}]})
+ src/main/haskell/Hydra/Encode/Json/Model.hs view
@@ -0,0 +1,45 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.json.model++module Hydra.Encode.Json.Model where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.json.model.Value+value :: Model.Value -> Core.Term+value x =+    case x of+      Model.ValueArray v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "array"),+          Core.fieldTerm = (Core.TermList (Lists.map value v0))}})+      Model.ValueBoolean v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "boolean"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralBoolean v0))}})+      Model.ValueNull -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "null"),+          Core.fieldTerm = Core.TermUnit}})+      Model.ValueNumber v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "number"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralDecimal v0))}})+      Model.ValueObject v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (Core.TermList (Lists.map (\p -> Core.TermPair (Pairs.bimap (\x -> Core.TermLiteral (Core.LiteralString x)) value p)) v0))}})+      Model.ValueString v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "string"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralString v0))}})
+ src/main/haskell/Hydra/Encode/Packaging.hs view
@@ -0,0 +1,243 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.packaging++module Hydra.Encode.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Typing as Typing+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Packaging as Packaging+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.packaging.Definition+definition :: Packaging.Definition -> Core.Term+definition x =+    case x of+      Packaging.DefinitionTerm v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (termDefinition v0)}})+      Packaging.DefinitionType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (typeDefinition v0)}})+      Packaging.DefinitionPrimitive v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "primitive"),+          Core.fieldTerm = (primitiveDefinition v0)}})+-- | Encoder for hydra.packaging.DefinitionReference+definitionReference :: Packaging.DefinitionReference -> Core.Term+definitionReference x =+    case x of+      Packaging.DefinitionReferenceType v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Packaging.DefinitionReferenceTerm v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Packaging.DefinitionReferencePrimitive v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "primitive"),+          Core.fieldTerm = (EncodeCore.name v0)}})+-- | Encoder for hydra.packaging.EntityMetadata+entityMetadata :: Packaging.EntityMetadata -> Core.Term+entityMetadata x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Packaging.entityMetadataDescription x))},+        Core.Field {+          Core.fieldName = (Core.Name "comments"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) xs)) (Packaging.entityMetadataComments x))},+        Core.Field {+          Core.fieldName = (Core.Name "seeAlso"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map entityReference xs)) (Packaging.entityMetadataSeeAlso x))},+        Core.Field {+          Core.fieldName = (Core.Name "lifecycle"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map lifecycleInfo opt)) (Packaging.entityMetadataLifecycle x))}]})+-- | Encoder for hydra.packaging.EntityReference+entityReference :: Packaging.EntityReference -> Core.Term+entityReference x =+    case x of+      Packaging.EntityReferencePackage v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = (packageName v0)}})+      Packaging.EntityReferenceModule v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (moduleName v0)}})+      Packaging.EntityReferenceDefinition v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "definition"),+          Core.fieldTerm = (definitionReference v0)}})+-- | Encoder for hydra.packaging.LifecycleInfo+lifecycleInfo :: Packaging.LifecycleInfo -> Core.Term+lifecycleInfo x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "availableSince"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map version opt)) (Packaging.lifecycleInfoAvailableSince x))},+        Core.Field {+          Core.fieldName = (Core.Name "deprecatedSince"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map version opt)) (Packaging.lifecycleInfoDeprecatedSince x))}]})+-- | Encoder for hydra.packaging.Module+module_ :: Packaging.Module -> Core.Term+module_ x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Module"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (moduleName (Packaging.moduleName x))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map entityMetadata opt)) (Packaging.moduleMetadata x))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map moduleDependency xs)) (Packaging.moduleDependencies x))},+        Core.Field {+          Core.fieldName = (Core.Name "definitions"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map definition xs)) (Packaging.moduleDefinitions x))}]})+-- | Encoder for hydra.packaging.ModuleDependency+moduleDependency :: Packaging.ModuleDependency -> Core.Term+moduleDependency x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "module"),+          Core.fieldTerm = (moduleName (Packaging.moduleDependencyModule x))},+        Core.Field {+          Core.fieldName = (Core.Name "package"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map packageName opt)) (Packaging.moduleDependencyPackage x))}]})+-- | Encoder for hydra.packaging.ModuleName+moduleName :: Packaging.ModuleName -> Core.Term+moduleName x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.packaging.ModuleName"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Packaging.unModuleName x))})+-- | Encoder for hydra.packaging.Package+package :: Packaging.Package -> Core.Term+package x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.Package"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (packageName (Packaging.packageName x))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map entityMetadata opt)) (Packaging.packageMetadata x))},+        Core.Field {+          Core.fieldName = (Core.Name "dependencies"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map packageDependency xs)) (Packaging.packageDependencies x))},+        Core.Field {+          Core.fieldName = (Core.Name "modules"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map module_ xs)) (Packaging.packageModules x))}]})+-- | Encoder for hydra.packaging.PackageDependency+packageDependency :: Packaging.PackageDependency -> Core.Term+packageDependency x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PackageDependency"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (packageName (Packaging.packageDependencyName x))},+        Core.Field {+          Core.fieldName = (Core.Name "version"),+          Core.fieldTerm = (versionSpecifier (Packaging.packageDependencyVersion x))}]})+-- | Encoder for hydra.packaging.PackageName+packageName :: Packaging.PackageName -> Core.Term+packageName x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.packaging.PackageName"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Packaging.unPackageName x))})+-- | Encoder for hydra.packaging.PrimitiveDefinition+primitiveDefinition :: Packaging.PrimitiveDefinition -> Core.Term+primitiveDefinition x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Packaging.primitiveDefinitionName x))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map entityMetadata opt)) (Packaging.primitiveDefinitionMetadata x))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = (Typing.termSignature (Packaging.primitiveDefinitionSignature x))},+        Core.Field {+          Core.fieldName = (Core.Name "isPure"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Packaging.primitiveDefinitionIsPure x))},+        Core.Field {+          Core.fieldName = (Core.Name "isTotal"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Packaging.primitiveDefinitionIsTotal x))},+        Core.Field {+          Core.fieldName = (Core.Name "defaultImplementation"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map EncodeCore.term opt)) (Packaging.primitiveDefinitionDefaultImplementation x))}]})+-- | Encoder for hydra.packaging.TermDefinition+termDefinition :: Packaging.TermDefinition -> Core.Term+termDefinition x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Packaging.termDefinitionName x))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map entityMetadata opt)) (Packaging.termDefinitionMetadata x))},+        Core.Field {+          Core.fieldName = (Core.Name "signature"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map Typing.termSignature opt)) (Packaging.termDefinitionSignature x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (EncodeCore.term (Packaging.termDefinitionBody x))}]})+-- | Encoder for hydra.packaging.TypeDefinition+typeDefinition :: Packaging.TypeDefinition -> Core.Term+typeDefinition x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Packaging.typeDefinitionName x))},+        Core.Field {+          Core.fieldName = (Core.Name "metadata"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map entityMetadata opt)) (Packaging.typeDefinitionMetadata x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (EncodeCore.typeScheme (Packaging.typeDefinitionBody x))}]})+-- | Encoder for hydra.packaging.Version+version :: Packaging.Version -> Core.Term+version x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.packaging.Version"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Packaging.unVersion x))})+-- | Encoder for hydra.packaging.VersionSpecifier+versionSpecifier :: Packaging.VersionSpecifier -> Core.Term+versionSpecifier x =+    case x of+      Packaging.VersionSpecifierAny -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.packaging.VersionSpecifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "any"),+          Core.fieldTerm = Core.TermUnit}})
+ src/main/haskell/Hydra/Encode/Parsing.hs view
@@ -0,0 +1,47 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.parsing++module Hydra.Encode.Parsing where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Parsing as Parsing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.parsing.ParseError+parseError :: Parsing.ParseError -> Core.Term+parseError x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "message"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Parsing.parseErrorMessage x))},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Parsing.parseErrorRemainder x))}]})+-- | Encoder for hydra.parsing.ParseResult+parseResult :: (t0 -> Core.Term) -> Parsing.ParseResult t0 -> Core.Term+parseResult a x =+    case x of+      Parsing.ParseResultSuccess v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "success"),+          Core.fieldTerm = (parseSuccess a v0)}})+      Parsing.ParseResultFailure v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "failure"),+          Core.fieldTerm = (parseError v0)}})+-- | Encoder for hydra.parsing.ParseSuccess+parseSuccess :: (t0 -> Core.Term) -> Parsing.ParseSuccess t0 -> Core.Term+parseSuccess a x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "value"),+          Core.fieldTerm = (a (Parsing.parseSuccessValue x))},+        Core.Field {+          Core.fieldName = (Core.Name "remainder"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Parsing.parseSuccessRemainder x))}]})
+ src/main/haskell/Hydra/Encode/Paths.hs view
@@ -0,0 +1,304 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.paths++module Hydra.Encode.Paths where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Paths as Paths+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.paths.SubtermEdge+subtermEdge :: Paths.SubtermEdge -> Core.Term+subtermEdge x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (subtermNode (Paths.subtermEdgeSource x))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (subtermPath (Paths.subtermEdgePath x))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (subtermNode (Paths.subtermEdgeTarget x))}]})+-- | Encoder for hydra.paths.SubtermGraph+subtermGraph :: Paths.SubtermGraph -> Core.Term+subtermGraph x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtermNode xs)) (Paths.subtermGraphNodes x))},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtermEdge xs)) (Paths.subtermGraphEdges x))}]})+-- | Encoder for hydra.paths.SubtermNode+subtermNode :: Paths.SubtermNode -> Core.Term+subtermNode x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Paths.subtermNodeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Paths.subtermNodeLabel x))},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Paths.subtermNodeId x))}]})+-- | Encoder for hydra.paths.SubtermPath+subtermPath :: Paths.SubtermPath -> Core.Term+subtermPath x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),+      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtermStep xs)) (Paths.unSubtermPath x))})+-- | Encoder for hydra.paths.SubtermStep+subtermStep :: Paths.SubtermStep -> Core.Term+subtermStep x =+    case x of+      Paths.SubtermStepAnnotatedBody -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "annotatedBody"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepApplicationFunction -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "applicationFunction"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepApplicationArgument -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "applicationArgument"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepLambdaBody -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lambdaBody"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepUnionCasesDefault -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unionCasesDefault"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepUnionCasesBranch v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unionCasesBranch"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Paths.SubtermStepLetBody -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "letBody"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepLetBinding v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "letBinding"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Paths.SubtermStepListElement v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "listElement"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Paths.SubtermStepMapKey v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "mapKey"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Paths.SubtermStepMapValue v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "mapValue"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Paths.SubtermStepOptionalTerm -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "optionalTerm"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepProductTerm v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "productTerm"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Paths.SubtermStepRecordField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "recordField"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Paths.SubtermStepSetElement v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "setElement"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Paths.SubtermStepSumTerm -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "sumTerm"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepTypeLambdaBody -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeLambdaBody"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepTypeApplicationTerm -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeApplicationTerm"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepInjectionTerm -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "injectionTerm"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtermStepWrappedTerm -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wrappedTerm"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.paths.SubtypeEdge+subtypeEdge :: Paths.SubtypeEdge -> Core.Term+subtypeEdge x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "source"),+          Core.fieldTerm = (subtypeNode (Paths.subtypeEdgeSource x))},+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (subtypePath (Paths.subtypeEdgePath x))},+        Core.Field {+          Core.fieldName = (Core.Name "target"),+          Core.fieldTerm = (subtypeNode (Paths.subtypeEdgeTarget x))}]})+-- | Encoder for hydra.paths.SubtypeGraph+subtypeGraph :: Paths.SubtypeGraph -> Core.Term+subtypeGraph x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "nodes"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtypeNode xs)) (Paths.subtypeGraphNodes x))},+        Core.Field {+          Core.fieldName = (Core.Name "edges"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map subtypeEdge xs)) (Paths.subtypeGraphEdges x))}]})+-- | Encoder for hydra.paths.SubtypeNode+subtypeNode :: Paths.SubtypeNode -> Core.Term+subtypeNode x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Paths.subtypeNodeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "label"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Paths.subtypeNodeLabel x))},+        Core.Field {+          Core.fieldName = (Core.Name "id"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Paths.subtypeNodeId x))}]})+-- | Encoder for hydra.paths.SubtypePath+subtypePath :: Paths.SubtypePath -> Core.Term+subtypePath x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),+      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map subtypeStep xs)) (Paths.unSubtypePath x))})+-- | Encoder for hydra.paths.SubtypeStep+subtypeStep :: Paths.SubtypeStep -> Core.Term+subtypeStep x =+    case x of+      Paths.SubtypeStepAnnotatedBody -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "annotatedBody"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepApplicationFunction -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "applicationFunction"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepApplicationArgument -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "applicationArgument"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepEitherLeft -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "eitherLeft"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepEitherRight -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "eitherRight"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepForallBody -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "forallBody"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepFunctionDomain -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "functionDomain"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepFunctionCodomain -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "functionCodomain"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepListElement -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "listElement"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepMapKeys -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "mapKeys"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepMapValues -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "mapValues"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepOptionalElement -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "optionalElement"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepPairFirst -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pairFirst"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepPairSecond -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pairSecond"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepRecordField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "recordField"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Paths.SubtypeStepSetElement -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "setElement"),+          Core.fieldTerm = Core.TermUnit}})+      Paths.SubtypeStepUnionField v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unionField"),+          Core.fieldTerm = (EncodeCore.name v0)}})+      Paths.SubtypeStepWrappedType -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wrappedType"),+          Core.fieldTerm = Core.TermUnit}})
+ src/main/haskell/Hydra/Encode/Query.hs view
@@ -0,0 +1,278 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.query++module Hydra.Encode.Query where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Query as Query+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.query.ComparisonConstraint+comparisonConstraint :: Query.ComparisonConstraint -> Core.Term+comparisonConstraint x =+    case x of+      Query.ComparisonConstraintEqual -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "equal"),+          Core.fieldTerm = Core.TermUnit}})+      Query.ComparisonConstraintNotEqual -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "notEqual"),+          Core.fieldTerm = Core.TermUnit}})+      Query.ComparisonConstraintLessThan -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lessThan"),+          Core.fieldTerm = Core.TermUnit}})+      Query.ComparisonConstraintGreaterThan -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "greaterThan"),+          Core.fieldTerm = Core.TermUnit}})+      Query.ComparisonConstraintLessThanOrEqual -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lessThanOrEqual"),+          Core.fieldTerm = Core.TermUnit}})+      Query.ComparisonConstraintGreaterThanOrEqual -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "greaterThanOrEqual"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.query.Edge+edge :: Query.Edge -> Core.Term+edge x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Edge"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.name (Query.edgeType x))},+        Core.Field {+          Core.fieldName = (Core.Name "out"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map EncodeCore.name opt)) (Query.edgeOut x))},+        Core.Field {+          Core.fieldName = (Core.Name "in"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map EncodeCore.name opt)) (Query.edgeIn x))}]})+-- | Encoder for hydra.query.GraphPattern+graphPattern :: Query.GraphPattern -> Core.Term+graphPattern x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (EncodeCore.name (Query.graphPatternGraph x))},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map pattern xs)) (Query.graphPatternPatterns x))}]})+-- | Encoder for hydra.query.Node+node :: Query.Node -> Core.Term+node x =+    case x of+      Query.NodeTerm v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Node"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (EncodeCore.term v0)}})+      Query.NodeVariable v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Node"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = (variable v0)}})+      Query.NodeWildcard -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Node"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wildcard"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.query.Path+path :: Query.Path -> Core.Term+path x =+    case x of+      Query.PathStep v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Path"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "step"),+          Core.fieldTerm = (step v0)}})+      Query.PathRegex v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Path"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "regex"),+          Core.fieldTerm = (regexSequence v0)}})+      Query.PathInverse v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Path"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "inverse"),+          Core.fieldTerm = (path v0)}})+-- | Encoder for hydra.query.PathEquation+pathEquation :: Query.PathEquation -> Core.Term+pathEquation x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PathEquation"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (path (Query.pathEquationLeft x))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (path (Query.pathEquationRight x))}]})+-- | Encoder for hydra.query.Pattern+pattern :: Query.Pattern -> Core.Term+pattern x =+    case x of+      Query.PatternTriple v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "triple"),+          Core.fieldTerm = (triplePattern v0)}})+      Query.PatternNegation v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "negation"),+          Core.fieldTerm = (pattern v0)}})+      Query.PatternConjunction v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "conjunction"),+          Core.fieldTerm = (Core.TermList (Lists.map pattern v0))}})+      Query.PatternDisjunction v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "disjunction"),+          Core.fieldTerm = (Core.TermList (Lists.map pattern v0))}})+      Query.PatternGraph v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "graph"),+          Core.fieldTerm = (graphPattern v0)}})+-- | Encoder for hydra.query.PatternImplication+patternImplication :: Query.PatternImplication -> Core.Term+patternImplication x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "antecedent"),+          Core.fieldTerm = (pattern (Query.patternImplicationAntecedent x))},+        Core.Field {+          Core.fieldName = (Core.Name "consequent"),+          Core.fieldTerm = (pattern (Query.patternImplicationConsequent x))}]})+-- | Encoder for hydra.query.Query+query :: Query.Query -> Core.Term+query x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Query"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "variables"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map variable xs)) (Query.queryVariables x))},+        Core.Field {+          Core.fieldName = (Core.Name "patterns"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map pattern xs)) (Query.queryPatterns x))}]})+-- | Encoder for hydra.query.Range+range :: Query.Range -> Core.Term+range x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.Range"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "min"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Query.rangeMin x))},+        Core.Field {+          Core.fieldName = (Core.Name "max"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Query.rangeMax x))}]})+-- | Encoder for hydra.query.RegexQuantifier+regexQuantifier :: Query.RegexQuantifier -> Core.Term+regexQuantifier x =+    case x of+      Query.RegexQuantifierOne -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "one"),+          Core.fieldTerm = Core.TermUnit}})+      Query.RegexQuantifierZeroOrOne -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "zeroOrOne"),+          Core.fieldTerm = Core.TermUnit}})+      Query.RegexQuantifierZeroOrMore -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "zeroOrMore"),+          Core.fieldTerm = Core.TermUnit}})+      Query.RegexQuantifierOneOrMore -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "oneOrMore"),+          Core.fieldTerm = Core.TermUnit}})+      Query.RegexQuantifierExactly v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "exactly"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Query.RegexQuantifierAtLeast v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "atLeast"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+      Query.RegexQuantifierRange v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "range"),+          Core.fieldTerm = (range v0)}})+-- | Encoder for hydra.query.RegexSequence+regexSequence :: Query.RegexSequence -> Core.Term+regexSequence x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "path"),+          Core.fieldTerm = (path (Query.regexSequencePath x))},+        Core.Field {+          Core.fieldName = (Core.Name "quantifier"),+          Core.fieldTerm = (regexQuantifier (Query.regexSequenceQuantifier x))}]})+-- | Encoder for hydra.query.Step+step :: Query.Step -> Core.Term+step x =+    case x of+      Query.StepEdge v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Step"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "edge"),+          Core.fieldTerm = (edge v0)}})+      Query.StepProject v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Step"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "project"),+          Core.fieldTerm = (EncodeCore.projection v0)}})+      Query.StepCompare v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.query.Step"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "compare"),+          Core.fieldTerm = (comparisonConstraint v0)}})+-- | Encoder for hydra.query.TriplePattern+triplePattern :: Query.TriplePattern -> Core.Term+triplePattern x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "subject"),+          Core.fieldTerm = (node (Query.triplePatternSubject x))},+        Core.Field {+          Core.fieldName = (Core.Name "predicate"),+          Core.fieldTerm = (path (Query.triplePatternPredicate x))},+        Core.Field {+          Core.fieldName = (Core.Name "object"),+          Core.fieldTerm = (node (Query.triplePatternObject x))}]})+-- | Encoder for hydra.query.Variable+variable :: Query.Variable -> Core.Term+variable x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.query.Variable"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Query.unVariable x))})
+ src/main/haskell/Hydra/Encode/Relational.hs view
@@ -0,0 +1,90 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.relational++module Hydra.Encode.Relational where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Relational as Relational+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.relational.ColumnName+columnName :: Relational.ColumnName -> Core.Term+columnName x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Relational.unColumnName x))})+-- | Encoder for hydra.relational.ColumnSchema+columnSchema :: (t0 -> Core.Term) -> Relational.ColumnSchema t0 -> Core.Term+columnSchema t x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (columnName (Relational.columnSchemaName x))},+        Core.Field {+          Core.fieldName = (Core.Name "domain"),+          Core.fieldTerm = (t (Relational.columnSchemaDomain x))}]})+-- | Encoder for hydra.relational.ForeignKey+foreignKey :: Relational.ForeignKey -> Core.Term+foreignKey x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "foreignRelation"),+          Core.fieldTerm = (relationName (Relational.foreignKeyForeignRelation x))},+        Core.Field {+          Core.fieldName = (Core.Name "keys"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap columnName columnName m)) (Relational.foreignKeyKeys x))}]})+-- | Encoder for hydra.relational.PrimaryKey+primaryKey :: Relational.PrimaryKey -> Core.Term+primaryKey x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"),+      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map columnName xs)) (Relational.unPrimaryKey x))})+-- | Encoder for hydra.relational.Relation+relation :: (t0 -> Core.Term) -> Relational.Relation t0 -> Core.Term+relation v x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relation"),+      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map (row v) xs)) (Relational.unRelation x))})+-- | Encoder for hydra.relational.RelationName+relationName :: Relational.RelationName -> Core.Term+relationName x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Relational.unRelationName x))})+-- | Encoder for hydra.relational.RelationSchema+relationSchema :: (t0 -> Core.Term) -> Relational.RelationSchema t0 -> Core.Term+relationSchema t x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (relationName (Relational.relationSchemaName x))},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (columnSchema t) xs)) (Relational.relationSchemaColumns x))},+        Core.Field {+          Core.fieldName = (Core.Name "primaryKeys"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map primaryKey xs)) (Relational.relationSchemaPrimaryKeys x))},+        Core.Field {+          Core.fieldName = (Core.Name "foreignKeys"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map foreignKey xs)) (Relational.relationSchemaForeignKeys x))}]})+-- | Encoder for hydra.relational.Relationship+relationship :: Ord t0 => ((t0 -> Core.Term) -> Relational.Relationship t0 -> Core.Term)+relationship v x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"),+      Core.wrappedTermBody = ((\s -> Core.TermSet (Sets.map (\m -> Core.TermMap (Maps.bimap columnName v m)) s)) (Relational.unRelationship x))})+-- | Encoder for hydra.relational.Row+row :: (t0 -> Core.Term) -> Relational.Row t0 -> Core.Term+row v x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"),+      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map v xs)) (Relational.unRow x))})
+ src/main/haskell/Hydra/Encode/Tabular.hs view
@@ -0,0 +1,60 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.tabular++module Hydra.Encode.Tabular where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Relational as Relational+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Tabular as Tabular+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.tabular.ColumnType+columnType :: Tabular.ColumnType -> Core.Term+columnType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Relational.columnName (Tabular.columnTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Tabular.columnTypeType x))}]})+-- | Encoder for hydra.tabular.DataRow+dataRow :: (t0 -> Core.Term) -> Tabular.DataRow t0 -> Core.Term+dataRow v x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"),+      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map (\opt -> Core.TermOptional (Optionals.map v opt)) xs)) (Tabular.unDataRow x))})+-- | Encoder for hydra.tabular.HeaderRow+headerRow :: Tabular.HeaderRow -> Core.Term+headerRow x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"),+      Core.wrappedTermBody = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) xs)) (Tabular.unHeaderRow x))})+-- | Encoder for hydra.tabular.Table+table :: (t0 -> Core.Term) -> Tabular.Table t0 -> Core.Term+table v x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.Table"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "header"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map headerRow opt)) (Tabular.tableHeader x))},+        Core.Field {+          Core.fieldName = (Core.Name "data"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (dataRow v) xs)) (Tabular.tableData x))}]})+-- | Encoder for hydra.tabular.TableType+tableType :: Tabular.TableType -> Core.Term+tableType x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.tabular.TableType"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (Relational.relationName (Tabular.tableTypeName x))},+        Core.Field {+          Core.fieldName = (Core.Name "columns"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map columnType xs)) (Tabular.tableTypeColumns x))}]})
+ src/main/haskell/Hydra/Encode/Testing.hs view
@@ -0,0 +1,15 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.testing++module Hydra.Encode.Testing where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Testing as Testing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.testing.Tag+tag :: Testing.Tag -> Core.Term+tag x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.testing.Tag"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Testing.unTag x))})
+ src/main/haskell/Hydra/Encode/Topology.hs view
@@ -0,0 +1,43 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.topology++module Hydra.Encode.Topology where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Topology as Topology+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Encoder for hydra.topology.Graph+graph :: M.Map Int [Int] -> Core.Term+graph m = Core.TermMap (Maps.bimap vertex (\xs -> Core.TermList (Lists.map vertex xs)) m)+-- | Encoder for hydra.topology.TarjanState+tarjanState :: Topology.TarjanState -> Core.Term+tarjanState x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "counter"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Topology.tarjanStateCounter x))},+        Core.Field {+          Core.fieldName = (Core.Name "indices"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap vertex (\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) m)) (Topology.tarjanStateIndices x))},+        Core.Field {+          Core.fieldName = (Core.Name "lowLinks"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap vertex (\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) m)) (Topology.tarjanStateLowLinks x))},+        Core.Field {+          Core.fieldName = (Core.Name "stack"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map vertex xs)) (Topology.tarjanStateStack x))},+        Core.Field {+          Core.fieldName = (Core.Name "onStack"),+          Core.fieldTerm = ((\s -> Core.TermSet (Sets.map vertex s)) (Topology.tarjanStateOnStack x))},+        Core.Field {+          Core.fieldName = (Core.Name "sccs"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\xs2 -> Core.TermList (Lists.map vertex xs2)) xs)) (Topology.tarjanStateSccs x))}]})+-- | Encoder for hydra.topology.Vertex+vertex :: Int -> Core.Term+vertex x = Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x))
+ src/main/haskell/Hydra/Encode/Typed.hs view
@@ -0,0 +1,39 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.typed++module Hydra.Encode.Typed where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Typed as Typed+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.typed.TypedBinding+typedBinding :: t0 -> Typed.TypedBinding t1 -> Core.Term+typedBinding a x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typed.TypedBinding"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Typed.typedBindingName x))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (typedTerm a (Typed.typedBindingTerm x))}]})+-- | Encoder for hydra.typed.TypedTerm+typedTerm :: t0 -> Typed.TypedTerm t1 -> Core.Term+typedTerm a x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+      Core.wrappedTermBody = (EncodeCore.term (Typed.unTypedTerm x))})+-- | Encoder for hydra.typed.TypedTermDefinition+typedTermDefinition :: t0 -> Typed.TypedTermDefinition t1 -> Core.Term+typedTermDefinition a x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typed.TypedTermDefinition"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Typed.typedTermDefinitionName x))},+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (typedTerm a (Typed.typedTermDefinitionTerm x))}]})
+ src/main/haskell/Hydra/Encode/Typing.hs view
@@ -0,0 +1,166 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.typing++module Hydra.Encode.Typing where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Paths as Paths+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.typing.FunctionStructure+functionStructure :: (t0 -> Core.Term) -> Typing.FunctionStructure t0 -> Core.Term+functionStructure env x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParams"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.name xs)) (Typing.functionStructureTypeParams x))},+        Core.Field {+          Core.fieldName = (Core.Name "params"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.name xs)) (Typing.functionStructureParams x))},+        Core.Field {+          Core.fieldName = (Core.Name "bindings"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.binding xs)) (Typing.functionStructureBindings x))},+        Core.Field {+          Core.fieldName = (Core.Name "body"),+          Core.fieldTerm = (EncodeCore.term (Typing.functionStructureBody x))},+        Core.Field {+          Core.fieldName = (Core.Name "domains"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.type_ xs)) (Typing.functionStructureDomains x))},+        Core.Field {+          Core.fieldName = (Core.Name "codomain"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map EncodeCore.type_ opt)) (Typing.functionStructureCodomain x))},+        Core.Field {+          Core.fieldName = (Core.Name "environment"),+          Core.fieldTerm = (env (Typing.functionStructureEnvironment x))}]})+-- | Encoder for hydra.typing.InferenceContext+inferenceContext :: Typing.InferenceContext -> Core.Term+inferenceContext x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceContext"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "freshTypeVariableCount"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) (Typing.inferenceContextFreshTypeVariableCount x))},+        Core.Field {+          Core.fieldName = (Core.Name "trace"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map Paths.subtermStep xs)) (Typing.inferenceContextTrace x))}]})+-- | Encoder for hydra.typing.InferenceResult+inferenceResult :: Typing.InferenceResult -> Core.Term+inferenceResult x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "term"),+          Core.fieldTerm = (EncodeCore.term (Typing.inferenceResultTerm x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Typing.inferenceResultType x))},+        Core.Field {+          Core.fieldName = (Core.Name "subst"),+          Core.fieldTerm = (typeSubst (Typing.inferenceResultSubst x))},+        Core.Field {+          Core.fieldName = (Core.Name "classConstraints"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name EncodeCore.typeVariableConstraints m)) (Typing.inferenceResultClassConstraints x))},+        Core.Field {+          Core.fieldName = (Core.Name "context"),+          Core.fieldTerm = (inferenceContext (Typing.inferenceResultContext x))}]})+-- | Encoder for hydra.typing.Parameter+parameter :: Typing.Parameter -> Core.Term+parameter x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Typing.parameterName x))},+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Typing.parameterDescription x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Typing.parameterType x))},+        Core.Field {+          Core.fieldName = (Core.Name "isLazy"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralBoolean x2)) (Typing.parameterIsLazy x))}]})+-- | Encoder for hydra.typing.Result+result :: Typing.Result -> Core.Term+result x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.Result"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map (\x2 -> Core.TermLiteral (Core.LiteralString x2)) opt)) (Typing.resultDescription x))},+        Core.Field {+          Core.fieldName = (Core.Name "type"),+          Core.fieldTerm = (EncodeCore.type_ (Typing.resultType x))}]})+-- | Encoder for hydra.typing.TermSignature+termSignature :: Typing.TermSignature -> Core.Term+termSignature x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TermSignature"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeParameters"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map typeParameter xs)) (Typing.termSignatureTypeParameters x))},+        Core.Field {+          Core.fieldName = (Core.Name "parameters"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map parameter xs)) (Typing.termSignatureParameters x))},+        Core.Field {+          Core.fieldName = (Core.Name "result"),+          Core.fieldTerm = (result (Typing.termSignatureResult x))}]})+-- | Encoder for hydra.typing.TermSubst+termSubst :: Typing.TermSubst -> Core.Term+termSubst x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"),+      Core.wrappedTermBody = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name EncodeCore.term m)) (Typing.unTermSubst x))})+-- | Encoder for hydra.typing.TypeClass+typeClass :: Typing.TypeClass -> Core.Term+typeClass x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeClass"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "description"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Typing.typeClassDescription x))}]})+-- | Encoder for hydra.typing.TypeConstraint+typeConstraint :: Typing.TypeConstraint -> Core.Term+typeConstraint x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "left"),+          Core.fieldTerm = (EncodeCore.type_ (Typing.typeConstraintLeft x))},+        Core.Field {+          Core.fieldName = (Core.Name "right"),+          Core.fieldTerm = (EncodeCore.type_ (Typing.typeConstraintRight x))},+        Core.Field {+          Core.fieldName = (Core.Name "comment"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Typing.typeConstraintComment x))}]})+-- | Encoder for hydra.typing.TypeParameter+typeParameter :: Typing.TypeParameter -> Core.Term+typeParameter x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.typing.TypeParameter"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "name"),+          Core.fieldTerm = (EncodeCore.name (Typing.typeParameterName x))},+        Core.Field {+          Core.fieldName = (Core.Name "constraints"),+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map EncodeCore.typeClassConstraint xs)) (Typing.typeParameterConstraints x))}]})+-- | Encoder for hydra.typing.TypeSubst+typeSubst :: Typing.TypeSubst -> Core.Term+typeSubst x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"),+      Core.wrappedTermBody = ((\m -> Core.TermMap (Maps.bimap EncodeCore.name EncodeCore.type_ m)) (Typing.unTypeSubst x))})
+ src/main/haskell/Hydra/Encode/Util.hs view
@@ -0,0 +1,100 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.util++module Hydra.Encode.Util where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Encode.Packaging as Packaging+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.util.CaseConvention+caseConvention :: Util.CaseConvention -> Core.Term+caseConvention x =+    case x of+      Util.CaseConventionCamel -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "camel"),+          Core.fieldTerm = Core.TermUnit}})+      Util.CaseConventionPascal -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pascal"),+          Core.fieldTerm = Core.TermUnit}})+      Util.CaseConventionLowerSnake -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lowerSnake"),+          Core.fieldTerm = Core.TermUnit}})+      Util.CaseConventionUpperSnake -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "upperSnake"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.util.Comparison+comparison :: Util.Comparison -> Core.Term+comparison x =+    case x of+      Util.ComparisonLessThan -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lessThan"),+          Core.fieldTerm = Core.TermUnit}})+      Util.ComparisonEqualTo -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "equalTo"),+          Core.fieldTerm = Core.TermUnit}})+      Util.ComparisonGreaterThan -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "greaterThan"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.util.FileExtension+fileExtension :: Util.FileExtension -> Core.Term+fileExtension x =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.util.FileExtension"),+      Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Util.unFileExtension x))})+-- | Encoder for hydra.util.ModuleNames+moduleNames :: (t0 -> Core.Term) -> Util.ModuleNames t0 -> Core.Term+moduleNames n x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.ModuleNames"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "focus"),+          Core.fieldTerm = ((\p -> Core.TermPair (Pairs.bimap Packaging.moduleName n p)) (Util.moduleNamesFocus x))},+        Core.Field {+          Core.fieldName = (Core.Name "mapping"),+          Core.fieldTerm = ((\m -> Core.TermMap (Maps.bimap Packaging.moduleName n m)) (Util.moduleNamesMapping x))}]})+-- | Encoder for hydra.util.Precision+precision :: Util.Precision -> Core.Term+precision x =+    case x of+      Util.PrecisionArbitrary -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.Precision"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "arbitrary"),+          Core.fieldTerm = Core.TermUnit}})+      Util.PrecisionBits v0 -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.util.Precision"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "bits"),+          Core.fieldTerm = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 v0)))}})+-- | Encoder for hydra.util.QualifiedName+qualifiedName :: Util.QualifiedName -> Core.Term+qualifiedName x =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.util.QualifiedName"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "moduleName"),+          Core.fieldTerm = ((\opt -> Core.TermOptional (Optionals.map Packaging.moduleName opt)) (Util.qualifiedNameModuleName x))},+        Core.Field {+          Core.fieldName = (Core.Name "local"),+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Util.qualifiedNameLocal x))}]})
+ src/main/haskell/Hydra/Encode/Variants.hs view
@@ -0,0 +1,241 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Term encoders for hydra.variants++module Hydra.Encode.Variants where+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Encoder for hydra.variants.LiteralVariant+literalVariant :: Variants.LiteralVariant -> Core.Term+literalVariant x =+    case x of+      Variants.LiteralVariantBinary -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "binary"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.LiteralVariantBoolean -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "boolean"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.LiteralVariantDecimal -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "decimal"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.LiteralVariantFloat -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "float"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.LiteralVariantInteger -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "integer"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.LiteralVariantString -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "string"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.variants.TermVariant+termVariant :: Variants.TermVariant -> Core.Term+termVariant x =+    case x of+      Variants.TermVariantAnnotated -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "annotated"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantApplication -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "application"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantCases -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "cases"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantEither -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "either"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantInject -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "inject"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantLambda -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "lambda"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantLet -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "let"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantList -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "list"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantLiteral -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "literal"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantMap -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "map"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantOptional -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "optional"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantPair -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pair"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantProject -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "project"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantRecord -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "record"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantSet -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "set"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantTypeApplication -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeApplication"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantTypeLambda -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "typeLambda"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantUnit -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unit"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantUnwrap -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unwrap"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantVariable -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TermVariantWrap -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wrap"),+          Core.fieldTerm = Core.TermUnit}})+-- | Encoder for hydra.variants.TypeVariant+typeVariant :: Variants.TypeVariant -> Core.Term+typeVariant x =+    case x of+      Variants.TypeVariantAnnotated -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "annotated"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantApplication -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "application"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantEither -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "either"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantForall -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "forall"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantFunction -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "function"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantList -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "list"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantLiteral -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "literal"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantMap -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "map"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantOptional -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "optional"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantPair -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pair"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantRecord -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "record"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantSet -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "set"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantUnion -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "union"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantUnit -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "unit"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantVariable -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "variable"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantVoid -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "void"),+          Core.fieldTerm = Core.TermUnit}})+      Variants.TypeVariantWrap -> Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wrap"),+          Core.fieldTerm = Core.TermUnit}})
+ src/main/haskell/Hydra/Encoding.hs view
@@ -0,0 +1,717 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Functions for generating term encoders from type modules++module Hydra.Encoding where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Predicates as Predicates+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Transform a type binding into an encoder binding+encodeBinding :: t0 -> Graph.Graph -> Core.Binding -> Either Errors.DecodingError Core.Binding+encodeBinding cx graph b =+    Eithers.bind (DecodeCore.type_ graph (Core.bindingTerm b)) (\typ ->+      let rawBody = encodeTypeNamed (Core.bindingName b) typ+          description =+                  Strings.cat [+                    "Encoder for ",+                    (Core.unName (Core.bindingName b))]+      in (Right (Core.Binding {+        Core.bindingName = (encodeBindingName (Core.bindingName b)),+        Core.bindingTerm = (Annotations.setTermDescription (Just description) rawBody),+        Core.bindingTypeScheme = (Just (encoderTypeSchemeNamed (Core.bindingName b) typ))})))+-- | Generate a binding name for an encoder function from a type name+encodeBindingName :: Core.Name -> Core.Name+encodeBindingName 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",+          "encode"] (Lists.concat2 tail [+          localPart])))))))+-- | Generate an encoder for an Either type+encodeEitherType :: Core.EitherType -> Core.Term+encodeEitherType et =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "e"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "either"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bimap")),+                Core.applicationArgument = (encodeType (Core.eitherTypeLeft et))})),+              Core.applicationArgument = (encodeType (Core.eitherTypeRight et))})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}}))})+-- | Generate the encoder for a field's value+encodeFieldValue :: Core.Name -> Core.Name -> Core.Type -> Core.Term+encodeFieldValue typeName fieldName fieldType =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "y"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "inject"),+          Core.fieldTerm = (encodeInjection typeName fieldName (Core.TermApplication (Core.Application {+            Core.applicationFunction = (encodeType fieldType),+            Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})))}}))})+-- | Encode a float value based on its float type+encodeFloatValue :: Core.FloatType -> Core.Term -> Core.Term+encodeFloatValue floatType valTerm =+    Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = case floatType of+          Core.FloatTypeFloat32 -> Core.Name "float32"+          Core.FloatTypeFloat64 -> Core.Name "float64",+        Core.fieldTerm = valTerm}})+-- | Generate an encoder for a polymorphic (forall) type+encodeForallType :: Core.ForallType -> Core.Term+encodeForallType ft =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (encodeBindingName (Core.forallTypeParameter ft)),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (encodeType (Core.forallTypeBody ft))})+-- | Encode an Injection as a term+encodeInjection :: Core.Name -> Core.Name -> Core.Term -> Core.Term+encodeInjection typeName fieldName fieldTerm =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = (Core.Name "hydra.core.Injection"),+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name "typeName"),+          Core.fieldTerm = (encodeName typeName)},+        Core.Field {+          Core.fieldName = (Core.Name "field"),+          Core.fieldTerm = ((\fname -> \fterm -> Core.TermRecord (Core.Record {+            Core.recordTypeName = (Core.Name "hydra.core.Field"),+            Core.recordFields = [+              Core.Field {+                Core.fieldName = (Core.Name "name"),+                Core.fieldTerm = (encodeName fname)},+              Core.Field {+                Core.fieldName = (Core.Name "term"),+                Core.fieldTerm = fterm}]})) fieldName fieldTerm)}]})+-- | Encode an integer value based on its integer type+encodeIntegerValue :: Core.IntegerType -> Core.Term -> Core.Term+encodeIntegerValue intType valTerm =+    Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+      Core.injectionField = Core.Field {+        Core.fieldName = case intType of+          Core.IntegerTypeBigint -> Core.Name "bigint"+          Core.IntegerTypeInt8 -> Core.Name "int8"+          Core.IntegerTypeInt16 -> Core.Name "int16"+          Core.IntegerTypeInt32 -> Core.Name "int32"+          Core.IntegerTypeInt64 -> Core.Name "int64"+          Core.IntegerTypeUint8 -> Core.Name "uint8"+          Core.IntegerTypeUint16 -> Core.Name "uint16"+          Core.IntegerTypeUint32 -> Core.Name "uint32"+          Core.IntegerTypeUint64 -> Core.Name "uint64",+        Core.fieldTerm = valTerm}})+-- | Generate an encoder for a list type+encodeListType :: Core.Type -> Core.Term+encodeListType elemType =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "xs"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "list"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+              Core.applicationArgument = (encodeType elemType)})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})+-- | Generate an encoder for a literal type+encodeLiteralType :: Core.LiteralType -> Core.Term+encodeLiteralType x =+    case x of+      Core.LiteralTypeBinary -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "literal"),+            Core.fieldTerm = (Core.TermInject (Core.Injection {+              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+              Core.injectionField = Core.Field {+                Core.fieldName = (Core.Name "binary"),+                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})+      Core.LiteralTypeBoolean -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "literal"),+            Core.fieldTerm = (Core.TermInject (Core.Injection {+              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+              Core.injectionField = Core.Field {+                Core.fieldName = (Core.Name "boolean"),+                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})+      Core.LiteralTypeDecimal -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "literal"),+            Core.fieldTerm = (Core.TermInject (Core.Injection {+              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+              Core.injectionField = Core.Field {+                Core.fieldName = (Core.Name "decimal"),+                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})+      Core.LiteralTypeString -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "literal"),+            Core.fieldTerm = (Core.TermInject (Core.Injection {+              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+              Core.injectionField = Core.Field {+                Core.fieldName = (Core.Name "string"),+                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})+      Core.LiteralTypeInteger v0 -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "literal"),+            Core.fieldTerm = (Core.TermInject (Core.Injection {+              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+              Core.injectionField = Core.Field {+                Core.fieldName = (Core.Name "integer"),+                Core.fieldTerm = (encodeIntegerValue v0 (Core.TermVariable (Core.Name "x")))}}))}}))})+      Core.LiteralTypeFloat v0 -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "literal"),+            Core.fieldTerm = (Core.TermInject (Core.Injection {+              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+              Core.injectionField = Core.Field {+                Core.fieldName = (Core.Name "float"),+                Core.fieldTerm = (encodeFloatValue v0 (Core.TermVariable (Core.Name "x")))}}))}}))})+      _ -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})+-- | Generate an encoder for a map type+encodeMapType :: Core.MapType -> Core.Term+encodeMapType mt =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "m"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "map"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                Core.applicationArgument = (encodeType (Core.mapTypeKeys mt))})),+              Core.applicationArgument = (encodeType (Core.mapTypeValues mt))})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})+-- | Transform a type module into an encoder module+encodeModule :: t0 -> Graph.Graph -> Packaging.Module -> Either Errors.Error (Maybe Packaging.Module)+encodeModule 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) (encodeBinding cx graph b)) typeBindings) (\encodedBindings -> Right (Just (Packaging.Module {+      Packaging.moduleName = (encodeModuleName (Packaging.moduleName mod)),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just (Strings.cat [+          "Term encoders 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.nub (Lists.concat2 (Lists.map encodeModuleName (Lists.map (\dep -> Packaging.moduleDependencyModule dep) (Packaging.moduleDependencies mod))) [+        Packaging.moduleName mod]))),+      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)})) encodedBindings)})))))+-- | Generate an encoder module name from a source module name+encodeModuleName :: Packaging.ModuleName -> Packaging.ModuleName+encodeModuleName 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.encode.",+        (Strings.intercalate "." (Pairs.second uc))])))+-- | Encode a Name as a term+encodeName :: Core.Name -> Core.Term+encodeName n =+    Core.TermWrap (Core.WrappedTerm {+      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString (Core.unName n)))})+-- | Generate an encoder for a Maybe type+encodeOptionalType :: Core.Type -> Core.Term+encodeOptionalType elemType =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "opt"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "optional"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+              Core.applicationArgument = (encodeType elemType)})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})+-- | Generate an encoder for a pair type+encodePairType :: Core.PairType -> Core.Term+encodePairType pt =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "p"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "pair"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")),+                Core.applicationArgument = (encodeType (Core.pairTypeFirst pt))})),+              Core.applicationArgument = (encodeType (Core.pairTypeSecond pt))})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))})+-- | Generate an encoder for a record type (unnamed — should not be called directly)+encodeRecordType :: [Core.FieldType] -> Core.Term+encodeRecordType rt = encodeRecordTypeNamed (Core.Name "unknown") rt+-- | Generate an encoder for a record type with the given element name+encodeRecordTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term+encodeRecordTypeNamed ename rt =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "record"),+          Core.fieldTerm = (Core.TermRecord (Core.Record {+            Core.recordTypeName = (Core.Name "hydra.core.Record"),+            Core.recordFields = [+              Core.Field {+                Core.fieldName = (Core.Name "typeName"),+                Core.fieldTerm = (encodeName ename)},+              Core.Field {+                Core.fieldName = (Core.Name "fields"),+                Core.fieldTerm = (Core.TermList (Lists.map ((\tname -> \recType -> \ft -> Core.TermRecord (Core.Record {+                  Core.recordTypeName = (Core.Name "hydra.core.Field"),+                  Core.recordFields = [+                    Core.Field {+                      Core.fieldName = (Core.Name "name"),+                      Core.fieldTerm = (encodeName (Core.fieldTypeName ft))},+                    Core.Field {+                      Core.fieldName = (Core.Name "term"),+                      Core.fieldTerm = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (encodeType (Core.fieldTypeType ft)),+                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermProject (Core.Projection {+                            Core.projectionTypeName = tname,+                            Core.projectionFieldName = (Core.fieldTypeName ft)})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})) ename rt) rt))}]}))}}))})+-- | Generate an encoder for a set type+encodeSetType :: Core.Type -> Core.Term+encodeSetType elemType =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "s"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "set"),+          Core.fieldTerm = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")),+              Core.applicationArgument = (encodeType elemType)})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})+-- | Generate an encoder term for a Type+encodeType :: Core.Type -> Core.Term+encodeType x =+    case x of+      Core.TypeAnnotated v0 -> encodeType (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Core.TermApplication (Core.Application {+        Core.applicationFunction = (encodeType (Core.applicationTypeFunction v0)),+        Core.applicationArgument = (encodeType (Core.applicationTypeArgument v0))})+      Core.TypeEither v0 -> encodeEitherType v0+      Core.TypeForall v0 -> encodeForallType v0+      Core.TypeFunction _ -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})+      Core.TypeList v0 -> encodeListType v0+      Core.TypeLiteral v0 -> encodeLiteralType v0+      Core.TypeMap v0 -> encodeMapType v0+      Core.TypeOptional v0 -> encodeOptionalType v0+      Core.TypePair v0 -> encodePairType v0+      Core.TypeRecord v0 -> encodeRecordType v0+      Core.TypeSet v0 -> encodeSetType v0+      Core.TypeUnion v0 -> encodeUnionType v0+      Core.TypeWrap v0 -> encodeWrappedType v0+      Core.TypeUnit -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "_"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "unit"),+            Core.fieldTerm = Core.TermUnit}}))})+      Core.TypeVoid -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "_"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "unit"),+            Core.fieldTerm = Core.TermUnit}}))})+      Core.TypeVariable v0 -> Core.TermVariable (encodeBindingName v0)+      _ -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})+-- | Generate an encoder term for a Type, with the element name for nominal types+encodeTypeNamed :: Core.Name -> Core.Type -> Core.Term+encodeTypeNamed ename typ =+    case typ of+      Core.TypeAnnotated v0 -> encodeTypeNamed ename (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Core.TermApplication (Core.Application {+        Core.applicationFunction = (encodeType (Core.applicationTypeFunction v0)),+        Core.applicationArgument = (encodeType (Core.applicationTypeArgument v0))})+      Core.TypeEither v0 -> encodeEitherType v0+      Core.TypeForall v0 -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (encodeBindingName (Core.forallTypeParameter v0)),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (encodeTypeNamed ename (Core.forallTypeBody v0))})+      Core.TypeFunction _ -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})+      Core.TypeList v0 -> encodeListType v0+      Core.TypeLiteral v0 -> encodeLiteralType v0+      Core.TypeMap v0 -> encodeMapType v0+      Core.TypeOptional v0 -> encodeOptionalType v0+      Core.TypePair v0 -> encodePairType v0+      Core.TypeRecord v0 -> encodeRecordTypeNamed ename v0+      Core.TypeSet v0 -> encodeSetType v0+      Core.TypeUnion v0 -> encodeUnionTypeNamed ename v0+      Core.TypeWrap v0 -> encodeWrappedTypeNamed ename v0+      Core.TypeUnit -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "_"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "unit"),+            Core.fieldTerm = Core.TermUnit}}))})+      Core.TypeVoid -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "_"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermInject (Core.Injection {+          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+          Core.injectionField = Core.Field {+            Core.fieldName = (Core.Name "unit"),+            Core.fieldTerm = Core.TermUnit}}))})+      Core.TypeVariable v0 -> Core.TermVariable (encodeBindingName v0)+      _ -> Core.TermLambda (Core.Lambda {+        Core.lambdaParameter = (Core.Name "x"),+        Core.lambdaDomain = Nothing,+        Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})+-- | Generate an encoder for a union type (placeholder name)+encodeUnionType :: [Core.FieldType] -> Core.Term+encodeUnionType rt = encodeUnionTypeNamed (Core.Name "unknown") rt+-- | Generate an encoder for a union type with the given element name+encodeUnionTypeNamed :: Core.Name -> [Core.FieldType] -> Core.Term+encodeUnionTypeNamed ename rt =+    Core.TermCases (Core.CaseStatement {+      Core.caseStatementTypeName = ename,+      Core.caseStatementDefault = Nothing,+      Core.caseStatementCases = (Lists.map (\ft -> Core.CaseAlternative {+        Core.caseAlternativeName = (Core.fieldTypeName ft),+        Core.caseAlternativeHandler = (encodeFieldValue ename (Core.fieldTypeName ft) (Core.fieldTypeType ft))}) rt)})+-- | Generate an encoder for a wrapped type (placeholder name)+encodeWrappedType :: Core.Type -> Core.Term+encodeWrappedType wt = encodeWrappedTypeNamed (Core.Name "unknown") wt+-- | Generate an encoder for a wrapped type with the given element name+encodeWrappedTypeNamed :: Core.Name -> Core.Type -> Core.Term+encodeWrappedTypeNamed ename wt =+    Core.TermLambda (Core.Lambda {+      Core.lambdaParameter = (Core.Name "x"),+      Core.lambdaDomain = Nothing,+      Core.lambdaBody = (Core.TermInject (Core.Injection {+        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+        Core.injectionField = Core.Field {+          Core.fieldName = (Core.Name "wrap"),+          Core.fieldTerm = (Core.TermRecord (Core.Record {+            Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+            Core.recordFields = [+              Core.Field {+                Core.fieldName = (Core.Name "typeName"),+                Core.fieldTerm = (encodeName ename)},+              Core.Field {+                Core.fieldName = (Core.Name "body"),+                Core.fieldTerm = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (encodeType wt),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermUnwrap ename),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})+-- | Collect forall type variable names from a type+encoderCollectForallVariables :: Core.Type -> [Core.Name]+encoderCollectForallVariables typ =+    case typ of+      Core.TypeAnnotated v0 -> encoderCollectForallVariables (Core.annotatedTypeBody v0)+      Core.TypeForall v0 -> Lists.cons (Core.forallTypeParameter v0) (encoderCollectForallVariables (Core.forallTypeBody v0))+      _ -> []+-- | Collect type variables needing Ord constraints+encoderCollectOrdVars :: Core.Type -> [Core.Name]+encoderCollectOrdVars typ =+    case typ of+      Core.TypeAnnotated v0 -> encoderCollectOrdVars (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Lists.concat2 (encoderCollectOrdVars (Core.applicationTypeFunction v0)) (encoderCollectOrdVars (Core.applicationTypeArgument v0))+      Core.TypeEither v0 -> Lists.concat2 (encoderCollectOrdVars (Core.eitherTypeLeft v0)) (encoderCollectOrdVars (Core.eitherTypeRight v0))+      Core.TypeForall v0 -> encoderCollectOrdVars (Core.forallTypeBody v0)+      Core.TypeList v0 -> encoderCollectOrdVars v0+      Core.TypeMap v0 -> Lists.concat [+        encoderCollectTypeVarsFromType (Core.mapTypeKeys v0),+        (encoderCollectOrdVars (Core.mapTypeKeys v0)),+        (encoderCollectOrdVars (Core.mapTypeValues v0))]+      Core.TypeOptional v0 -> encoderCollectOrdVars v0+      Core.TypePair v0 -> Lists.concat2 (encoderCollectOrdVars (Core.pairTypeFirst v0)) (encoderCollectOrdVars (Core.pairTypeSecond v0))+      Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> encoderCollectOrdVars (Core.fieldTypeType ft)) v0)+      Core.TypeSet v0 -> Lists.concat2 (encoderCollectTypeVarsFromType v0) (encoderCollectOrdVars v0)+      Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> encoderCollectOrdVars (Core.fieldTypeType ft)) v0)+      Core.TypeWrap v0 -> encoderCollectOrdVars v0+      _ -> []+-- | Collect all type variable names from a type expression+encoderCollectTypeVarsFromType :: Core.Type -> [Core.Name]+encoderCollectTypeVarsFromType typ =+    case typ of+      Core.TypeAnnotated v0 -> encoderCollectTypeVarsFromType (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Lists.concat2 (encoderCollectTypeVarsFromType (Core.applicationTypeFunction v0)) (encoderCollectTypeVarsFromType (Core.applicationTypeArgument v0))+      Core.TypeForall v0 -> encoderCollectTypeVarsFromType (Core.forallTypeBody v0)+      Core.TypeList v0 -> encoderCollectTypeVarsFromType v0+      Core.TypeMap v0 -> Lists.concat2 (encoderCollectTypeVarsFromType (Core.mapTypeKeys v0)) (encoderCollectTypeVarsFromType (Core.mapTypeValues v0))+      Core.TypeOptional v0 -> encoderCollectTypeVarsFromType v0+      Core.TypePair v0 -> Lists.concat2 (encoderCollectTypeVarsFromType (Core.pairTypeFirst v0)) (encoderCollectTypeVarsFromType (Core.pairTypeSecond v0))+      Core.TypeRecord v0 -> Lists.concat (Lists.map (\ft -> encoderCollectTypeVarsFromType (Core.fieldTypeType ft)) v0)+      Core.TypeSet v0 -> encoderCollectTypeVarsFromType v0+      Core.TypeUnion v0 -> Lists.concat (Lists.map (\ft -> encoderCollectTypeVarsFromType (Core.fieldTypeType ft)) v0)+      Core.TypeVariable v0 -> [+        v0]+      Core.TypeWrap v0 -> encoderCollectTypeVarsFromType v0+      _ -> []+-- | Get full result type for encoder input+encoderFullResultType :: Core.Type -> Core.Type+encoderFullResultType typ =+    case typ of+      Core.TypeAnnotated v0 -> encoderFullResultType (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType {+        Core.applicationTypeFunction = (encoderFullResultType (Core.applicationTypeFunction v0)),+        Core.applicationTypeArgument = (Core.applicationTypeArgument v0)})+      Core.TypeEither v0 -> Core.TypeEither (Core.EitherType {+        Core.eitherTypeLeft = (encoderFullResultType (Core.eitherTypeLeft v0)),+        Core.eitherTypeRight = (encoderFullResultType (Core.eitherTypeRight v0))})+      Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType {+        Core.applicationTypeFunction = (encoderFullResultType (Core.forallTypeBody v0)),+        Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))})+      Core.TypeList v0 -> Core.TypeList (encoderFullResultType v0)+      Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal")+      Core.TypeMap v0 -> Core.TypeMap (Core.MapType {+        Core.mapTypeKeys = (encoderFullResultType (Core.mapTypeKeys v0)),+        Core.mapTypeValues = (encoderFullResultType (Core.mapTypeValues v0))})+      Core.TypeOptional v0 -> Core.TypeOptional (encoderFullResultType v0)+      Core.TypePair v0 -> Core.TypePair (Core.PairType {+        Core.pairTypeFirst = (encoderFullResultType (Core.pairTypeFirst v0)),+        Core.pairTypeSecond = (encoderFullResultType (Core.pairTypeSecond v0))})+      Core.TypeRecord _ -> Core.TypeVariable (Core.Name "hydra.core.Term")+      Core.TypeSet v0 -> Core.TypeSet (encoderFullResultType 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 encoder input, using element name for nominal types+encoderFullResultTypeNamed :: Core.Name -> Core.Type -> Core.Type+encoderFullResultTypeNamed ename typ =+    case typ of+      Core.TypeAnnotated v0 -> encoderFullResultTypeNamed ename (Core.annotatedTypeBody v0)+      Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType {+        Core.applicationTypeFunction = (encoderFullResultType (Core.applicationTypeFunction v0)),+        Core.applicationTypeArgument = (Core.applicationTypeArgument v0)})+      Core.TypeEither v0 -> Core.TypeEither (Core.EitherType {+        Core.eitherTypeLeft = (encoderFullResultType (Core.eitherTypeLeft v0)),+        Core.eitherTypeRight = (encoderFullResultType (Core.eitherTypeRight v0))})+      Core.TypeForall v0 -> Core.TypeApplication (Core.ApplicationType {+        Core.applicationTypeFunction = (encoderFullResultTypeNamed ename (Core.forallTypeBody v0)),+        Core.applicationTypeArgument = (Core.TypeVariable (Core.forallTypeParameter v0))})+      Core.TypeList v0 -> Core.TypeList (encoderFullResultType v0)+      Core.TypeLiteral _ -> Core.TypeVariable (Core.Name "hydra.core.Literal")+      Core.TypeMap v0 -> Core.TypeMap (Core.MapType {+        Core.mapTypeKeys = (encoderFullResultType (Core.mapTypeKeys v0)),+        Core.mapTypeValues = (encoderFullResultType (Core.mapTypeValues v0))})+      Core.TypeOptional v0 -> Core.TypeOptional (encoderFullResultType v0)+      Core.TypePair v0 -> Core.TypePair (Core.PairType {+        Core.pairTypeFirst = (encoderFullResultType (Core.pairTypeFirst v0)),+        Core.pairTypeSecond = (encoderFullResultType (Core.pairTypeSecond v0))})+      Core.TypeRecord _ -> Core.TypeVariable ename+      Core.TypeSet v0 -> Core.TypeSet (encoderFullResultType v0)+      Core.TypeUnion _ -> Core.TypeVariable ename+      Core.TypeUnit -> Core.TypeUnit+      Core.TypeVariable v0 -> Core.TypeVariable v0+      Core.TypeVoid -> Core.TypeVoid+      Core.TypeWrap _ -> Core.TypeVariable ename+      _ -> Core.TypeVariable (Core.Name "hydra.core.Term")+-- | Build encoder function type+encoderType :: Core.Type -> Core.Type+encoderType typ =++      let resultType = encoderFullResultType typ+          baseType =+                  Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = resultType,+                    Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})+      in (prependForallEncoders baseType typ)+-- | Build encoder function type with element name for nominal types+encoderTypeNamed :: Core.Name -> Core.Type -> Core.Type+encoderTypeNamed ename typ =++      let resultType = encoderFullResultTypeNamed ename typ+          baseType =+                  Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = resultType,+                    Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})+      in (prependForallEncoders baseType typ)+-- | Construct a TypeScheme for an encoder function from a source type+encoderTypeScheme :: Core.Type -> Core.TypeScheme+encoderTypeScheme typ =++      let typeVars = encoderCollectForallVariables typ+          encoderFunType = encoderType typ+          allOrdVars = encoderCollectOrdVars typ+          ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars+          constraints =+                  Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (+                    v,+                    Core.TypeVariableConstraints {+                      Core.typeVariableConstraintsClasses = [+                        Core.TypeClassConstraintSimple (Core.Name "ordering")]})) ordVars)))+      in Core.TypeScheme {+        Core.typeSchemeVariables = typeVars,+        Core.typeSchemeBody = encoderFunType,+        Core.typeSchemeConstraints = constraints}+-- | Construct a TypeScheme for an encoder function, with element name for nominal types+encoderTypeSchemeNamed :: Core.Name -> Core.Type -> Core.TypeScheme+encoderTypeSchemeNamed ename typ =++      let typeVars = encoderCollectForallVariables typ+          encoderFunType = encoderTypeNamed ename typ+          allOrdVars = encoderCollectOrdVars typ+          ordVars = Lists.filter (\v -> Lists.elem v typeVars) allOrdVars+          constraints =+                  Logic.ifElse (Lists.null ordVars) Nothing (Just (Maps.fromList (Lists.map (\v -> (+                    v,+                    Core.TypeVariableConstraints {+                      Core.typeVariableConstraintsClasses = [+                        Core.TypeClassConstraintSimple (Core.Name "ordering")]})) ordVars)))+      in Core.TypeScheme {+        Core.typeSchemeVariables = typeVars,+        Core.typeSchemeBody = encoderFunType,+        Core.typeSchemeConstraints = constraints}+-- | Filter bindings to only encodable type definitions+filterTypeBindings :: t0 -> Graph.Graph -> [Core.Binding] -> Either Errors.Error [Core.Binding]+filterTypeBindings cx graph bindings =+    Eithers.map Optionals.cat (Eithers.mapList (isEncodableBinding cx graph) (Lists.filter Annotations.isNativeType bindings))+-- | Check if a binding is encodable (serializable type)+isEncodableBinding :: t0 -> Graph.Graph -> Core.Binding -> Either Errors.Error (Maybe Core.Binding)+isEncodableBinding cx graph b =+    Eithers.bind (Predicates.isSerializableByName cx graph (Core.bindingName b)) (\serializable -> Right (Logic.ifElse serializable (Just b) Nothing))+-- | Check whether a type is the unit type+isUnitType :: Core.Type -> Bool+isUnitType x =+    case x of+      Core.TypeUnit -> True+      _ -> False+-- | Prepend encoder types for forall parameters to base type+prependForallEncoders :: Core.Type -> Core.Type -> Core.Type+prependForallEncoders baseType typ =+    case typ of+      Core.TypeAnnotated v0 -> prependForallEncoders baseType (Core.annotatedTypeBody v0)+      Core.TypeForall v0 -> Core.TypeFunction (Core.FunctionType {+        Core.functionTypeDomain = (Core.TypeFunction (Core.FunctionType {+          Core.functionTypeDomain = (Core.TypeVariable (Core.forallTypeParameter v0)),+          Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+        Core.functionTypeCodomain = (prependForallEncoders baseType (Core.forallTypeBody v0))})+      _ -> baseType
+ src/main/haskell/Hydra/Environment.hs view
@@ -0,0 +1,169 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Graph to type environment conversions++module Hydra.Environment where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Convert a definition to a typed term+definitionAsTypeApplicationTerm :: Core.Binding -> Either Errors.Error Core.TypeApplicationTerm+definitionAsTypeApplicationTerm el =+    Optionals.cases (Core.bindingTypeScheme el) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      Errors.unexpectedShapeErrorExpected = "typed binding",+      Errors.unexpectedShapeErrorActual = "untyped binding"})))) (\ts -> Right (Core.TypeApplicationTerm {+      Core.typeApplicationTermBody = (Core.bindingTerm el),+      Core.typeApplicationTermType = (Core.typeSchemeBody ts)}))+-- | Convert bindings and a body to a let expression+graphAsLet :: [Core.Binding] -> Core.Term -> Core.Let+graphAsLet bindings body =+    Core.Let {+      Core.letBindings = bindings,+      Core.letBody = body}+-- | Convert bindings and a body to a term, using let-term duality+graphAsTerm :: [Core.Binding] -> Core.Term -> Core.Term+graphAsTerm bindings body = Core.TermLet (graphAsLet bindings body)+-- | Decode a list of type-encoding bindings into a map of named types+graphAsTypes :: Graph.Graph -> [Core.Binding] -> Either Errors.DecodingError (M.Map Core.Name Core.Type)+graphAsTypes graph els =++      let toPair = \el -> Eithers.map (\typ -> (Core.bindingName el, typ)) (DecodeCore.type_ graph (Core.bindingTerm el))+      in (Eithers.map Maps.fromList (Eithers.mapList toPair els))+-- | Partition a list of definitions into type definitions and term definitions+partitionDefinitions :: [Packaging.Definition] -> ([Packaging.TypeDefinition], [Packaging.TermDefinition])+partitionDefinitions defs =++      let getType =+              \def -> case def of+                Packaging.DefinitionType v0 -> Just v0+                Packaging.DefinitionTerm _ -> Nothing+                Packaging.DefinitionPrimitive _ -> Nothing+          getTerm =+                  \def -> case def of+                    Packaging.DefinitionType _ -> Nothing+                    Packaging.DefinitionTerm v0 -> Just v0+                    Packaging.DefinitionPrimitive _ -> Nothing+      in (Optionals.cat (Lists.map getType defs), (Optionals.cat (Lists.map getTerm defs)))+-- | Reorder definitions: types first (with hydra.core.Name first among types), then topologically sorted terms+reorderDefs :: [Packaging.Definition] -> [Packaging.Definition]+reorderDefs defs =++      let partitioned = partitionDefinitions defs+          typeDefsRaw = Pairs.first partitioned+          nameFirst =+                  Lists.filter (\td -> Equality.equal (Packaging.typeDefinitionName td) (Core.Name "hydra.core.Name")) typeDefsRaw+          nameRest =+                  Lists.filter (\td -> Logic.not (Equality.equal (Packaging.typeDefinitionName td) (Core.Name "hydra.core.Name"))) typeDefsRaw+          typeDefs =+                  Lists.concat [+                    Lists.map (\td -> Packaging.DefinitionType td) nameFirst,+                    (Lists.map (\td -> Packaging.DefinitionType td) nameRest)]+          termDefsWrapped = Lists.map (\td -> Packaging.DefinitionTerm td) (Pairs.second partitioned)+          sortedTermDefs =+                  Lists.concat (Sorting.topologicalSortNodes (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Packaging.termDefinitionName v0) (\d -> case d of+                    Packaging.DefinitionTerm v0 -> Sets.toList (Variables.freeVariablesInTerm (Packaging.termDefinitionBody v0))+                    _ -> []) termDefsWrapped)+      in (Lists.concat [+        typeDefs,+        sortedTermDefs])+-- | Convert a schema graph to a typing environment (Either version)+schemaGraphToTypingEnvironment :: Graph.Graph -> Either Errors.Error (M.Map Core.Name Core.TypeScheme)+schemaGraphToTypingEnvironment g =++      let toTypeScheme =+              \vars -> \typ -> case (Strip.deannotateType typ) of+                Core.TypeForall v0 -> toTypeScheme (Lists.cons (Core.forallTypeParameter v0) vars) (Core.forallTypeBody v0)+                _ -> Core.TypeScheme {+                  Core.typeSchemeVariables = (Lists.reverse vars),+                  Core.typeSchemeBody = typ,+                  Core.typeSchemeConstraints = Nothing}+          decodeType = \term -> Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\_a -> _a) (DecodeCore.type_ g term)+          decodeTypeScheme = \term -> Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\_a -> _a) (DecodeCore.typeScheme g term)+          toPair =+                  \el ->+                    let forTerm =+                            \term -> case term of+                              Core.TermRecord v0 -> Logic.ifElse (Equality.equal (Core.recordTypeName v0) (Core.Name "hydra.core.TypeScheme")) (Eithers.map Optionals.pure (decodeTypeScheme (Core.bindingTerm el))) (Right Nothing)+                              Core.TermInject v0 -> Logic.ifElse (Equality.equal (Core.injectionTypeName v0) (Core.Name "hydra.core.Type")) (Eithers.map (\decoded -> Just (toTypeScheme [] decoded)) (decodeType (Core.bindingTerm el))) (Right Nothing)+                              _ -> Right Nothing+                    in (Eithers.bind (Optionals.cases (Core.bindingTypeScheme el) (Eithers.map (\typ -> Just (Scoping.fTypeToTypeScheme typ)) (decodeType (Core.bindingTerm el))) (\ts -> Logic.ifElse (Equality.equal ts (Core.TypeScheme {+                      Core.typeSchemeVariables = [],+                      Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme")),+                      Core.typeSchemeConstraints = Nothing})) (Eithers.map Optionals.pure (decodeTypeScheme (Core.bindingTerm el))) (Logic.ifElse (Equality.equal ts (Core.TypeScheme {+                      Core.typeSchemeVariables = [],+                      Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                      Core.typeSchemeConstraints = Nothing})) (Eithers.map (\decoded -> Just (toTypeScheme [] decoded)) (decodeType (Core.bindingTerm el))) (forTerm (Strip.deannotateTerm (Core.bindingTerm el)))))) (\mts -> Right (Optionals.map (\ts -> (Core.bindingName el, ts)) mts)))+      in (Eithers.map (\mpairs -> Maps.fromList (Optionals.cat mpairs)) (Eithers.mapList toPair (Lexical.graphToBindings g)))+-- | Extract the bindings from a let term, or return an empty list for other terms+termAsBindings :: Core.Term -> [Core.Binding]+termAsBindings term =+    case (Strip.deannotateTerm term) of+      Core.TermLet v0 -> Core.letBindings v0+      _ -> []+-- | Encode a map of named types to a list of bindings+typesToDefinitions :: M.Map Core.Name Core.Type -> [Core.Binding]+typesToDefinitions typeMap =++      let toElement =+              \pair ->+                let name = Pairs.first pair+                in Core.Binding {+                  Core.bindingName = name,+                  Core.bindingTerm = (EncodeCore.type_ (Pairs.second pair)),+                  Core.bindingTypeScheme = Nothing}+      in (Lists.map toElement (Maps.toList typeMap))+-- | Execute a computation in the context of a lambda body, extending the type context with the lambda parameter+withLambdaContext :: (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t1) -> t0 -> Core.Lambda -> (t1 -> t2) -> t2+withLambdaContext getContext setContext env lam body =++      let newContext = Scoping.extendGraphForLambda (getContext env) lam+      in (body (setContext newContext env))+-- | Execute a computation in the context of a let body, extending the type context with the let bindings+withLetContext :: (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t1) -> (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> t0 -> Core.Let -> (t1 -> t2) -> t2+withLetContext getContext setContext forBinding env letrec body =++      let newContext = Scoping.extendGraphForLet forBinding (getContext env) letrec+      in (body (setContext newContext env))+-- | Execute a computation in the context of a type lambda body, extending the type context with the type parameter+withTypeLambdaContext :: (t0 -> Graph.Graph) -> (Graph.Graph -> t0 -> t1) -> t0 -> Core.TypeLambda -> (t1 -> t2) -> t2+withTypeLambdaContext getContext setContext env tlam body =++      let newContext = Scoping.extendGraphForTypeLambda (getContext env) tlam+      in (body (setContext newContext env))
+ src/main/haskell/Hydra/Error/Checking.hs view
@@ -0,0 +1,185 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Error types for type checking++module Hydra.Error.Checking where+import qualified Hydra.Core as Core+import qualified Hydra.Paths as Paths+import qualified Hydra.Typing as Typing+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | An error that occurred during type checking+data CheckingError =+  -- | A post-unification consistency check failure+  CheckingErrorIncorrectUnification IncorrectUnificationError |+  -- | A type that is not a forall type when one was expected+  CheckingErrorNotAForallType NotAForallTypeError |+  -- | A type that is not a function type when one was expected+  CheckingErrorNotAFunctionType NotAFunctionTypeError |+  -- | A generic checking error+  CheckingErrorOther OtherCheckingError |+  -- | A type constructor applied to the wrong number of arguments+  CheckingErrorTypeArityMismatch TypeArityMismatchError |+  -- | A type mismatch between expected and actual types+  CheckingErrorTypeMismatch TypeMismatchError |+  -- | Type variables that are not bound in scope+  CheckingErrorUnboundTypeVariables UnboundTypeVariablesError |+  -- | A reference to a term variable that is not bound in scope, encountered during checking+  CheckingErrorUndefinedTermVariable UndefinedTermVariableCheckingError |+  -- | Multiple types that should be equal but are not+  CheckingErrorUnequalTypes UnequalTypesError |+  -- | A term variant that the type checker does not support+  CheckingErrorUnsupportedTermVariant UnsupportedTermVariantError |+  -- | A lambda expression without a type annotation on its parameter+  CheckingErrorUntypedLambda UntypedLambdaError |+  -- | A let binding without a type annotation+  CheckingErrorUntypedLetBinding UntypedLetBindingError |+  -- | A reference to a term variable whose type is not known, encountered during checking+  CheckingErrorUntypedTermVariable UntypedTermVariableCheckingError+  deriving (Eq, Ord, Read, Show)+_CheckingError = Core.Name "hydra.error.checking.CheckingError"+_CheckingError_incorrectUnification = Core.Name "incorrectUnification"+_CheckingError_notAForallType = Core.Name "notAForallType"+_CheckingError_notAFunctionType = Core.Name "notAFunctionType"+_CheckingError_other = Core.Name "other"+_CheckingError_typeArityMismatch = Core.Name "typeArityMismatch"+_CheckingError_typeMismatch = Core.Name "typeMismatch"+_CheckingError_unboundTypeVariables = Core.Name "unboundTypeVariables"+_CheckingError_undefinedTermVariable = Core.Name "undefinedTermVariable"+_CheckingError_unequalTypes = Core.Name "unequalTypes"+_CheckingError_unsupportedTermVariant = Core.Name "unsupportedTermVariant"+_CheckingError_untypedLambda = Core.Name "untypedLambda"+_CheckingError_untypedLetBinding = Core.Name "untypedLetBinding"+_CheckingError_untypedTermVariable = Core.Name "untypedTermVariable"+-- | A post-unification consistency check failure+data IncorrectUnificationError =+  IncorrectUnificationError {+    -- | The substitution that failed the consistency check+    incorrectUnificationErrorSubstitution :: Typing.TypeSubst}+  deriving (Eq, Ord, Read, Show)+_IncorrectUnificationError = Core.Name "hydra.error.checking.IncorrectUnificationError"+_IncorrectUnificationError_substitution = Core.Name "substitution"+-- | A type that is not a forall type when type arguments are being applied+data NotAForallTypeError =+  NotAForallTypeError {+    -- | The actual type encountered+    notAForallTypeErrorType :: Core.Type,+    -- | The type arguments that were being applied+    notAForallTypeErrorTypeArguments :: [Core.Type]}+  deriving (Eq, Ord, Read, Show)+_NotAForallTypeError = Core.Name "hydra.error.checking.NotAForallTypeError"+_NotAForallTypeError_type = Core.Name "type"+_NotAForallTypeError_typeArguments = Core.Name "typeArguments"+-- | A type that is not a function type when one was expected in an application+data NotAFunctionTypeError =+  NotAFunctionTypeError {+    -- | The actual type encountered+    notAFunctionTypeErrorType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_NotAFunctionTypeError = Core.Name "hydra.error.checking.NotAFunctionTypeError"+_NotAFunctionTypeError_type = Core.Name "type"+-- | A generic checking error: message + subterm path+data OtherCheckingError =+  OtherCheckingError {+    -- | The subterm path at which the error was observed+    otherCheckingErrorPath :: Paths.SubtermPath,+    -- | A human-readable error message+    otherCheckingErrorMessage :: String}+  deriving (Eq, Ord, Read, Show)+_OtherCheckingError = Core.Name "hydra.error.checking.OtherCheckingError"+_OtherCheckingError_path = Core.Name "path"+_OtherCheckingError_message = Core.Name "message"+-- | A type constructor applied to the wrong number of type arguments+data TypeArityMismatchError =+  TypeArityMismatchError {+    -- | The type being checked+    typeArityMismatchErrorType :: Core.Type,+    -- | The expected number of type arguments+    typeArityMismatchErrorExpectedArity :: Int,+    -- | The actual number of type arguments provided+    typeArityMismatchErrorActualArity :: Int,+    -- | The type arguments that were provided+    typeArityMismatchErrorTypeArguments :: [Core.Type]}+  deriving (Eq, Ord, Read, Show)+_TypeArityMismatchError = Core.Name "hydra.error.checking.TypeArityMismatchError"+_TypeArityMismatchError_type = Core.Name "type"+_TypeArityMismatchError_expectedArity = Core.Name "expectedArity"+_TypeArityMismatchError_actualArity = Core.Name "actualArity"+_TypeArityMismatchError_typeArguments = Core.Name "typeArguments"+-- | A type mismatch between expected and actual types+data TypeMismatchError =+  TypeMismatchError {+    -- | The expected type+    typeMismatchErrorExpectedType :: Core.Type,+    -- | The actual type encountered+    typeMismatchErrorActualType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_TypeMismatchError = Core.Name "hydra.error.checking.TypeMismatchError"+_TypeMismatchError_expectedType = Core.Name "expectedType"+_TypeMismatchError_actualType = Core.Name "actualType"+-- | Type variables that appear free in a type but are not bound in scope+data UnboundTypeVariablesError =+  UnboundTypeVariablesError {+    -- | The set of unbound type variable names+    unboundTypeVariablesErrorVariables :: (S.Set Core.Name),+    -- | The type containing the unbound variables+    unboundTypeVariablesErrorType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_UnboundTypeVariablesError = Core.Name "hydra.error.checking.UnboundTypeVariablesError"+_UnboundTypeVariablesError_variables = Core.Name "variables"+_UnboundTypeVariablesError_type = Core.Name "type"+-- | A reference to a term variable that is not bound in scope, encountered during checking+data UndefinedTermVariableCheckingError =+  UndefinedTermVariableCheckingError {+    -- | The subterm path at which the variable was referenced+    undefinedTermVariableCheckingErrorPath :: Paths.SubtermPath,+    -- | The name of the undefined variable+    undefinedTermVariableCheckingErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UndefinedTermVariableCheckingError = Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"+_UndefinedTermVariableCheckingError_path = Core.Name "path"+_UndefinedTermVariableCheckingError_name = Core.Name "name"+-- | Multiple types that should all be equal but are not+data UnequalTypesError =+  UnequalTypesError {+    -- | The list of types that are not all equal+    unequalTypesErrorTypes :: [Core.Type],+    -- | A description of the context in which the types were expected to be equal+    unequalTypesErrorDescription :: String}+  deriving (Eq, Ord, Read, Show)+_UnequalTypesError = Core.Name "hydra.error.checking.UnequalTypesError"+_UnequalTypesError_types = Core.Name "types"+_UnequalTypesError_description = Core.Name "description"+-- | A term variant that the type checker does not support+data UnsupportedTermVariantError =+  UnsupportedTermVariantError {+    -- | The unsupported term variant+    unsupportedTermVariantErrorTermVariant :: Variants.TermVariant}+  deriving (Eq, Ord, Read, Show)+_UnsupportedTermVariantError = Core.Name "hydra.error.checking.UnsupportedTermVariantError"+_UnsupportedTermVariantError_termVariant = Core.Name "termVariant"+-- | A lambda expression without a type annotation on its parameter+data UntypedLambdaError =+  UntypedLambdaError {}+  deriving (Eq, Ord, Read, Show)+_UntypedLambdaError = Core.Name "hydra.error.checking.UntypedLambdaError"+-- | A let binding without a type annotation+data UntypedLetBindingError =+  UntypedLetBindingError {+    -- | The untyped binding+    untypedLetBindingErrorBinding :: Core.Binding}+  deriving (Eq, Ord, Read, Show)+_UntypedLetBindingError = Core.Name "hydra.error.checking.UntypedLetBindingError"+_UntypedLetBindingError_binding = Core.Name "binding"+-- | A reference to a term variable whose type is not known, encountered during checking+data UntypedTermVariableCheckingError =+  UntypedTermVariableCheckingError {+    -- | The subterm path at which the variable was referenced+    untypedTermVariableCheckingErrorPath :: Paths.SubtermPath,+    -- | The name of the untyped variable+    untypedTermVariableCheckingErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UntypedTermVariableCheckingError = Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"+_UntypedTermVariableCheckingError_path = Core.Name "path"+_UntypedTermVariableCheckingError_name = Core.Name "name"
+ src/main/haskell/Hydra/Error/Core.hs view
@@ -0,0 +1,542 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Error types for core type and term validation++module Hydra.Error.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Paths as Paths+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | An application of ifElse where the condition is a literal boolean, creating a dead branch (optional)+data ConstantConditionError =+  ConstantConditionError {+    -- | The path to the constant condition within the term+    constantConditionErrorLocation :: Paths.SubtermPath,+    -- | The constant boolean value of the condition+    constantConditionErrorValue :: Bool}+  deriving (Eq, Ord, Read, Show)+_ConstantConditionError = Core.Name "hydra.error.core.ConstantConditionError"+_ConstantConditionError_location = Core.Name "location"+_ConstantConditionError_value = Core.Name "value"+-- | A duplicate binding name in a let expression+data DuplicateBindingError =+  DuplicateBindingError {+    -- | The path to the duplicate binding within the term+    duplicateBindingErrorLocation :: Paths.SubtermPath,+    -- | The duplicated binding name+    duplicateBindingErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_DuplicateBindingError = Core.Name "hydra.error.core.DuplicateBindingError"+_DuplicateBindingError_location = Core.Name "location"+_DuplicateBindingError_name = Core.Name "name"+-- | A duplicate field name in a record or union type+data DuplicateFieldError =+  DuplicateFieldError {+    -- | The path to the duplicate field within the term+    duplicateFieldErrorLocation :: Paths.SubtermPath,+    -- | The duplicated field name+    duplicateFieldErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_DuplicateFieldError = Core.Name "hydra.error.core.DuplicateFieldError"+_DuplicateFieldError_location = Core.Name "location"+_DuplicateFieldError_name = Core.Name "name"+-- | A record type with duplicate field names+data DuplicateRecordTypeFieldNamesError =+  DuplicateRecordTypeFieldNamesError {+    -- | The path to the record type with duplicate fields+    duplicateRecordTypeFieldNamesErrorLocation :: Paths.SubtermPath,+    -- | The duplicated field name+    duplicateRecordTypeFieldNamesErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_DuplicateRecordTypeFieldNamesError = Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"+_DuplicateRecordTypeFieldNamesError_location = Core.Name "location"+_DuplicateRecordTypeFieldNamesError_name = Core.Name "name"+-- | A union type with duplicate field names+data DuplicateUnionTypeFieldNamesError =+  DuplicateUnionTypeFieldNamesError {+    -- | The path to the union type with duplicate fields+    duplicateUnionTypeFieldNamesErrorLocation :: Paths.SubtermPath,+    -- | The duplicated field name+    duplicateUnionTypeFieldNamesErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_DuplicateUnionTypeFieldNamesError = Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"+_DuplicateUnionTypeFieldNamesError_location = Core.Name "location"+_DuplicateUnionTypeFieldNamesError_name = Core.Name "name"+-- | A case statement with no cases and no default (optional)+data EmptyCaseStatementError =+  EmptyCaseStatementError {+    -- | The path to the empty case statement within the term+    emptyCaseStatementErrorLocation :: Paths.SubtermPath,+    -- | The name of the union type being matched+    emptyCaseStatementErrorTypeName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_EmptyCaseStatementError = Core.Name "hydra.error.core.EmptyCaseStatementError"+_EmptyCaseStatementError_location = Core.Name "location"+_EmptyCaseStatementError_typeName = Core.Name "typeName"+-- | A let expression with an empty list of bindings (optional)+data EmptyLetBindingsError =+  EmptyLetBindingsError {+    -- | The path to the empty let expression within the term+    emptyLetBindingsErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_EmptyLetBindingsError = Core.Name "hydra.error.core.EmptyLetBindingsError"+_EmptyLetBindingsError_location = Core.Name "location"+-- | A record type with no fields; TypeUnit is preferred for the unit-like case (optional)+data EmptyRecordTypeError =+  EmptyRecordTypeError {+    -- | The path to the empty record type+    emptyRecordTypeErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_EmptyRecordTypeError = Core.Name "hydra.error.core.EmptyRecordTypeError"+_EmptyRecordTypeError_location = Core.Name "location"+-- | A term annotation with an empty annotation map (optional)+data EmptyTermAnnotationError =+  EmptyTermAnnotationError {+    -- | The path to the empty annotation within the term+    emptyTermAnnotationErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_EmptyTermAnnotationError = Core.Name "hydra.error.core.EmptyTermAnnotationError"+_EmptyTermAnnotationError_location = Core.Name "location"+-- | A type annotation with an empty annotation map (optional)+data EmptyTypeAnnotationError =+  EmptyTypeAnnotationError {+    -- | The path to the empty annotation+    emptyTypeAnnotationErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_EmptyTypeAnnotationError = Core.Name "hydra.error.core.EmptyTypeAnnotationError"+_EmptyTypeAnnotationError_location = Core.Name "location"+-- | A record, injection, projection, or case statement with an empty type name (optional)+data EmptyTypeNameInTermError =+  EmptyTypeNameInTermError {+    -- | The path to the term with the empty type name+    emptyTypeNameInTermErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_EmptyTypeNameInTermError = Core.Name "hydra.error.core.EmptyTypeNameInTermError"+_EmptyTypeNameInTermError_location = Core.Name "location"+-- | A union type with no alternatives; TypeVoid is preferred (optional)+data EmptyUnionTypeError =+  EmptyUnionTypeError {+    -- | The path to the empty union type+    emptyUnionTypeErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_EmptyUnionTypeError = Core.Name "hydra.error.core.EmptyUnionTypeError"+_EmptyUnionTypeError_location = Core.Name "location"+-- | A forall type parameter name that violates type variable naming conventions (optional)+data InvalidForallParameterNameError =+  InvalidForallParameterNameError {+    -- | The path to the forall type+    invalidForallParameterNameErrorLocation :: Paths.SubtermPath,+    -- | The invalid parameter name+    invalidForallParameterNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_InvalidForallParameterNameError = Core.Name "hydra.error.core.InvalidForallParameterNameError"+_InvalidForallParameterNameError_location = Core.Name "location"+_InvalidForallParameterNameError_name = Core.Name "name"+-- | A lambda parameter name that violates naming conventions (optional)+data InvalidLambdaParameterNameError =+  InvalidLambdaParameterNameError {+    -- | The path to the lambda within the term+    invalidLambdaParameterNameErrorLocation :: Paths.SubtermPath,+    -- | The invalid parameter name+    invalidLambdaParameterNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_InvalidLambdaParameterNameError = Core.Name "hydra.error.core.InvalidLambdaParameterNameError"+_InvalidLambdaParameterNameError_location = Core.Name "location"+_InvalidLambdaParameterNameError_name = Core.Name "name"+-- | A let binding name that violates naming conventions (optional)+data InvalidLetBindingNameError =+  InvalidLetBindingNameError {+    -- | The path to the binding within the term+    invalidLetBindingNameErrorLocation :: Paths.SubtermPath,+    -- | The invalid binding name+    invalidLetBindingNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_InvalidLetBindingNameError = Core.Name "hydra.error.core.InvalidLetBindingNameError"+_InvalidLetBindingNameError_location = Core.Name "location"+_InvalidLetBindingNameError_name = Core.Name "name"+-- | An error indicating that a literal value is invalid+data InvalidLiteralError =+  -- | The literal's type does not match the expected literal type+  InvalidLiteralErrorTypeMismatch LiteralTypeMismatchError+  deriving (Eq, Ord, Read, Show)+_InvalidLiteralError = Core.Name "hydra.error.core.InvalidLiteralError"+_InvalidLiteralError_typeMismatch = Core.Name "typeMismatch"+-- | An error indicating that a term is invalid+data InvalidTermError =+  -- | An ifElse with a literal boolean condition (optional)+  InvalidTermErrorConstantCondition ConstantConditionError |+  -- | A duplicate binding name in a let expression+  InvalidTermErrorDuplicateBinding DuplicateBindingError |+  -- | A duplicate field name in a record or case statement+  InvalidTermErrorDuplicateField DuplicateFieldError |+  -- | A case statement with no cases and no default (optional)+  InvalidTermErrorEmptyCaseStatement EmptyCaseStatementError |+  -- | A let expression with no bindings (optional)+  InvalidTermErrorEmptyLetBindings EmptyLetBindingsError |+  -- | A term annotation with an empty annotation map (optional)+  InvalidTermErrorEmptyTermAnnotation EmptyTermAnnotationError |+  -- | A term with an empty type name (optional)+  InvalidTermErrorEmptyTypeNameInTerm EmptyTypeNameInTermError |+  -- | A lambda parameter name violating naming conventions (optional)+  InvalidTermErrorInvalidLambdaParameterName InvalidLambdaParameterNameError |+  -- | A let binding name violating naming conventions (optional)+  InvalidTermErrorInvalidLetBindingName InvalidLetBindingNameError |+  -- | A type lambda parameter name violating naming conventions (optional)+  InvalidTermErrorInvalidTypeLambdaParameterName InvalidTypeLambdaParameterNameError |+  -- | Nested term annotations that should be merged (optional)+  InvalidTermErrorNestedTermAnnotation NestedTermAnnotationError |+  -- | A no-op unwrap-of-wrap round-trip (optional)+  InvalidTermErrorRedundantWrapUnwrap RedundantWrapUnwrapError |+  -- | A variable applied to itself (optional)+  InvalidTermErrorSelfApplication SelfApplicationError |+  -- | A binding that shadows a variable already in scope (optional)+  InvalidTermErrorTermVariableShadowing TermVariableShadowingError |+  -- | A type lambda parameter that shadows a type variable in scope (optional)+  InvalidTermErrorTypeVariableShadowingInTypeLambda TypeVariableShadowingInTypeLambdaError |+  -- | A variable reference to an unbound term name+  InvalidTermErrorUndefinedTermVariable UndefinedTermVariableError |+  -- | An unbound type variable in a let binding's type scheme+  InvalidTermErrorUndefinedTypeVariableInBindingType UndefinedTypeVariableInBindingTypeError |+  -- | An unbound type variable in a lambda domain annotation+  InvalidTermErrorUndefinedTypeVariableInLambdaDomain UndefinedTypeVariableInLambdaDomainError |+  -- | An unbound type variable in a type application term+  InvalidTermErrorUndefinedTypeVariableInTypeApplication UndefinedTypeVariableInTypeApplicationError |+  -- | A reference to an unknown primitive function+  InvalidTermErrorUnknownPrimitiveName UnknownPrimitiveNameError |+  -- | An identity lambda applied to an argument (optional)+  InvalidTermErrorUnnecessaryIdentityApplication UnnecessaryIdentityApplicationError |+  -- | A term variable whose type is not known+  InvalidTermErrorUntypedTermVariable UntypedTermVariableError+  deriving (Eq, Ord, Read, Show)+_InvalidTermError = Core.Name "hydra.error.core.InvalidTermError"+_InvalidTermError_constantCondition = Core.Name "constantCondition"+_InvalidTermError_duplicateBinding = Core.Name "duplicateBinding"+_InvalidTermError_duplicateField = Core.Name "duplicateField"+_InvalidTermError_emptyCaseStatement = Core.Name "emptyCaseStatement"+_InvalidTermError_emptyLetBindings = Core.Name "emptyLetBindings"+_InvalidTermError_emptyTermAnnotation = Core.Name "emptyTermAnnotation"+_InvalidTermError_emptyTypeNameInTerm = Core.Name "emptyTypeNameInTerm"+_InvalidTermError_invalidLambdaParameterName = Core.Name "invalidLambdaParameterName"+_InvalidTermError_invalidLetBindingName = Core.Name "invalidLetBindingName"+_InvalidTermError_invalidTypeLambdaParameterName = Core.Name "invalidTypeLambdaParameterName"+_InvalidTermError_nestedTermAnnotation = Core.Name "nestedTermAnnotation"+_InvalidTermError_redundantWrapUnwrap = Core.Name "redundantWrapUnwrap"+_InvalidTermError_selfApplication = Core.Name "selfApplication"+_InvalidTermError_termVariableShadowing = Core.Name "termVariableShadowing"+_InvalidTermError_typeVariableShadowingInTypeLambda = Core.Name "typeVariableShadowingInTypeLambda"+_InvalidTermError_undefinedTermVariable = Core.Name "undefinedTermVariable"+_InvalidTermError_undefinedTypeVariableInBindingType = Core.Name "undefinedTypeVariableInBindingType"+_InvalidTermError_undefinedTypeVariableInLambdaDomain = Core.Name "undefinedTypeVariableInLambdaDomain"+_InvalidTermError_undefinedTypeVariableInTypeApplication = Core.Name "undefinedTypeVariableInTypeApplication"+_InvalidTermError_unknownPrimitiveName = Core.Name "unknownPrimitiveName"+_InvalidTermError_unnecessaryIdentityApplication = Core.Name "unnecessaryIdentityApplication"+_InvalidTermError_untypedTermVariable = Core.Name "untypedTermVariable"+-- | An error indicating that a type is invalid+data InvalidTypeError =+  -- | A record type with duplicate field names+  InvalidTypeErrorDuplicateRecordTypeFieldNames DuplicateRecordTypeFieldNamesError |+  -- | A union type with duplicate field names+  InvalidTypeErrorDuplicateUnionTypeFieldNames DuplicateUnionTypeFieldNamesError |+  -- | A record type with no fields (optional)+  InvalidTypeErrorEmptyRecordType EmptyRecordTypeError |+  -- | A type annotation with an empty annotation map (optional)+  InvalidTypeErrorEmptyTypeAnnotation EmptyTypeAnnotationError |+  -- | A union type with no alternatives (optional)+  InvalidTypeErrorEmptyUnionType EmptyUnionTypeError |+  -- | A forall parameter name violating naming conventions (optional)+  InvalidTypeErrorInvalidForallParameterName InvalidForallParameterNameError |+  -- | A type scheme variable name violating naming conventions (optional)+  InvalidTypeErrorInvalidTypeSchemeVariableName InvalidTypeSchemeVariableNameError |+  -- | Nested type annotations that should be merged (optional)+  InvalidTypeErrorNestedTypeAnnotation NestedTypeAnnotationError |+  -- | A map with a non-comparable key type+  InvalidTypeErrorNonComparableMapKeyType NonComparableMapKeyTypeError |+  -- | A set with a non-comparable element type+  InvalidTypeErrorNonComparableSetElementType NonComparableSetElementTypeError |+  -- | A union type with only one variant (optional)+  InvalidTypeErrorSingleVariantUnion SingleVariantUnionError |+  -- | A forall parameter that shadows a type variable in scope (optional)+  InvalidTypeErrorTypeVariableShadowingInForall TypeVariableShadowingInForallError |+  -- | A type variable reference to an unbound name+  InvalidTypeErrorUndefinedTypeVariable UndefinedTypeVariableError |+  -- | TypeVoid in a position where no value can be constructed (optional)+  InvalidTypeErrorVoidInNonBottomPosition VoidInNonBottomPositionError+  deriving (Eq, Ord, Read, Show)+_InvalidTypeError = Core.Name "hydra.error.core.InvalidTypeError"+_InvalidTypeError_duplicateRecordTypeFieldNames = Core.Name "duplicateRecordTypeFieldNames"+_InvalidTypeError_duplicateUnionTypeFieldNames = Core.Name "duplicateUnionTypeFieldNames"+_InvalidTypeError_emptyRecordType = Core.Name "emptyRecordType"+_InvalidTypeError_emptyTypeAnnotation = Core.Name "emptyTypeAnnotation"+_InvalidTypeError_emptyUnionType = Core.Name "emptyUnionType"+_InvalidTypeError_invalidForallParameterName = Core.Name "invalidForallParameterName"+_InvalidTypeError_invalidTypeSchemeVariableName = Core.Name "invalidTypeSchemeVariableName"+_InvalidTypeError_nestedTypeAnnotation = Core.Name "nestedTypeAnnotation"+_InvalidTypeError_nonComparableMapKeyType = Core.Name "nonComparableMapKeyType"+_InvalidTypeError_nonComparableSetElementType = Core.Name "nonComparableSetElementType"+_InvalidTypeError_singleVariantUnion = Core.Name "singleVariantUnion"+_InvalidTypeError_typeVariableShadowingInForall = Core.Name "typeVariableShadowingInForall"+_InvalidTypeError_undefinedTypeVariable = Core.Name "undefinedTypeVariable"+_InvalidTypeError_voidInNonBottomPosition = Core.Name "voidInNonBottomPosition"+-- | A type lambda parameter name that violates naming conventions (optional)+data InvalidTypeLambdaParameterNameError =+  InvalidTypeLambdaParameterNameError {+    -- | The path to the type lambda within the term+    invalidTypeLambdaParameterNameErrorLocation :: Paths.SubtermPath,+    -- | The invalid type lambda parameter name+    invalidTypeLambdaParameterNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_InvalidTypeLambdaParameterNameError = Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"+_InvalidTypeLambdaParameterNameError_location = Core.Name "location"+_InvalidTypeLambdaParameterNameError_name = Core.Name "name"+-- | A type scheme variable name that violates type variable naming conventions (optional)+data InvalidTypeSchemeVariableNameError =+  InvalidTypeSchemeVariableNameError {+    -- | The path to the type scheme+    invalidTypeSchemeVariableNameErrorLocation :: Paths.SubtermPath,+    -- | The invalid variable name+    invalidTypeSchemeVariableNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_InvalidTypeSchemeVariableNameError = Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"+_InvalidTypeSchemeVariableNameError_location = Core.Name "location"+_InvalidTypeSchemeVariableNameError_name = Core.Name "name"+-- | A mismatch between an expected literal type and the type of an actual literal value+data LiteralTypeMismatchError =+  LiteralTypeMismatchError {+    -- | The expected literal type+    literalTypeMismatchErrorExpectedType :: Core.LiteralType,+    -- | The actual literal type, derived from the value+    literalTypeMismatchErrorActualType :: Core.LiteralType}+  deriving (Eq, Ord, Read, Show)+_LiteralTypeMismatchError = Core.Name "hydra.error.core.LiteralTypeMismatchError"+_LiteralTypeMismatchError_expectedType = Core.Name "expectedType"+_LiteralTypeMismatchError_actualType = Core.Name "actualType"+-- | A term annotation directly wrapping another term annotation; annotations should be merged (optional)+data NestedTermAnnotationError =+  NestedTermAnnotationError {+    -- | The path to the outer annotation within the term+    nestedTermAnnotationErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_NestedTermAnnotationError = Core.Name "hydra.error.core.NestedTermAnnotationError"+_NestedTermAnnotationError_location = Core.Name "location"+-- | A type annotation directly wrapping another type annotation; annotations should be merged (optional)+data NestedTypeAnnotationError =+  NestedTypeAnnotationError {+    -- | The path to the outer annotation+    nestedTypeAnnotationErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_NestedTypeAnnotationError = Core.Name "hydra.error.core.NestedTypeAnnotationError"+_NestedTypeAnnotationError_location = Core.Name "location"+-- | A map type whose key type is or directly contains a function type, which cannot be compared for equality+data NonComparableMapKeyTypeError =+  NonComparableMapKeyTypeError {+    -- | The path to the map type+    nonComparableMapKeyTypeErrorLocation :: Paths.SubtermPath,+    -- | The non-comparable key type+    nonComparableMapKeyTypeErrorKeyType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_NonComparableMapKeyTypeError = Core.Name "hydra.error.core.NonComparableMapKeyTypeError"+_NonComparableMapKeyTypeError_location = Core.Name "location"+_NonComparableMapKeyTypeError_keyType = Core.Name "keyType"+-- | A set type whose element type is or directly contains a function type, which cannot be compared for equality+data NonComparableSetElementTypeError =+  NonComparableSetElementTypeError {+    -- | The path to the set type+    nonComparableSetElementTypeErrorLocation :: Paths.SubtermPath,+    -- | The non-comparable element type+    nonComparableSetElementTypeErrorElementType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_NonComparableSetElementTypeError = Core.Name "hydra.error.core.NonComparableSetElementTypeError"+_NonComparableSetElementTypeError_location = Core.Name "location"+_NonComparableSetElementTypeError_elementType = Core.Name "elementType"+-- | An unwrap elimination applied to a wrap term of the same type, forming a no-op round-trip (optional)+data RedundantWrapUnwrapError =+  RedundantWrapUnwrapError {+    -- | The path to the redundant wrap/unwrap within the term+    redundantWrapUnwrapErrorLocation :: Paths.SubtermPath,+    -- | The type name of the wrapper+    redundantWrapUnwrapErrorTypeName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_RedundantWrapUnwrapError = Core.Name "hydra.error.core.RedundantWrapUnwrapError"+_RedundantWrapUnwrapError_location = Core.Name "location"+_RedundantWrapUnwrapError_typeName = Core.Name "typeName"+-- | A variable applied to itself, which is almost always a mistake in Hydra's type system (optional)+data SelfApplicationError =+  SelfApplicationError {+    -- | The path to the self-application within the term+    selfApplicationErrorLocation :: Paths.SubtermPath,+    -- | The name of the variable applied to itself+    selfApplicationErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_SelfApplicationError = Core.Name "hydra.error.core.SelfApplicationError"+_SelfApplicationError_location = Core.Name "location"+_SelfApplicationError_name = Core.Name "name"+-- | A union type with exactly one field; could be a wrapped type or record instead (optional)+data SingleVariantUnionError =+  SingleVariantUnionError {+    -- | The path to the single-variant union type+    singleVariantUnionErrorLocation :: Paths.SubtermPath,+    -- | The name of the single field+    singleVariantUnionErrorFieldName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_SingleVariantUnionError = Core.Name "hydra.error.core.SingleVariantUnionError"+_SingleVariantUnionError_location = Core.Name "location"+_SingleVariantUnionError_fieldName = Core.Name "fieldName"+-- | A lambda parameter or let binding name that shadows a variable already in scope (optional)+data TermVariableShadowingError =+  TermVariableShadowingError {+    -- | The path to the shadowing binding within the term+    termVariableShadowingErrorLocation :: Paths.SubtermPath,+    -- | The name of the shadowed variable+    termVariableShadowingErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_TermVariableShadowingError = Core.Name "hydra.error.core.TermVariableShadowingError"+_TermVariableShadowingError_location = Core.Name "location"+_TermVariableShadowingError_name = Core.Name "name"+-- | A forall type parameter that shadows a type variable already in scope (optional)+data TypeVariableShadowingInForallError =+  TypeVariableShadowingInForallError {+    -- | The path to the shadowing forall type+    typeVariableShadowingInForallErrorLocation :: Paths.SubtermPath,+    -- | The name of the shadowed type variable+    typeVariableShadowingInForallErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_TypeVariableShadowingInForallError = Core.Name "hydra.error.core.TypeVariableShadowingInForallError"+_TypeVariableShadowingInForallError_location = Core.Name "location"+_TypeVariableShadowingInForallError_name = Core.Name "name"+-- | A type lambda parameter that shadows a type variable already in scope (optional)+data TypeVariableShadowingInTypeLambdaError =+  TypeVariableShadowingInTypeLambdaError {+    -- | The path to the type lambda within the term+    typeVariableShadowingInTypeLambdaErrorLocation :: Paths.SubtermPath,+    -- | The name of the shadowed type variable+    typeVariableShadowingInTypeLambdaErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_TypeVariableShadowingInTypeLambdaError = Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"+_TypeVariableShadowingInTypeLambdaError_location = Core.Name "location"+_TypeVariableShadowingInTypeLambdaError_name = Core.Name "name"+-- | A reference to a field that does not exist in the given type+data UndefinedFieldError =+  UndefinedFieldError {+    -- | The name of the undefined field+    undefinedFieldErrorFieldName :: Core.Name,+    -- | The name of the type in which the field was expected+    undefinedFieldErrorTypeName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UndefinedFieldError = Core.Name "hydra.error.core.UndefinedFieldError"+_UndefinedFieldError_fieldName = Core.Name "fieldName"+_UndefinedFieldError_typeName = Core.Name "typeName"+-- | A variable reference to a term name that is not bound in scope+data UndefinedTermVariableError =+  UndefinedTermVariableError {+    -- | The path to the undefined variable within the term+    undefinedTermVariableErrorLocation :: Paths.SubtermPath,+    -- | The name of the undefined variable+    undefinedTermVariableErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UndefinedTermVariableError = Core.Name "hydra.error.core.UndefinedTermVariableError"+_UndefinedTermVariableError_location = Core.Name "location"+_UndefinedTermVariableError_name = Core.Name "name"+-- | A type variable reference to a name that is not bound in scope+data UndefinedTypeVariableError =+  UndefinedTypeVariableError {+    -- | The path to the undefined type variable+    undefinedTypeVariableErrorLocation :: Paths.SubtermPath,+    -- | The name of the undefined type variable+    undefinedTypeVariableErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UndefinedTypeVariableError = Core.Name "hydra.error.core.UndefinedTypeVariableError"+_UndefinedTypeVariableError_location = Core.Name "location"+_UndefinedTypeVariableError_name = Core.Name "name"+-- | A type variable in a let binding's type scheme that is not bound by the scheme or enclosing scope+data UndefinedTypeVariableInBindingTypeError =+  UndefinedTypeVariableInBindingTypeError {+    -- | The path to the binding within the term+    undefinedTypeVariableInBindingTypeErrorLocation :: Paths.SubtermPath,+    -- | The name of the undefined type variable+    undefinedTypeVariableInBindingTypeErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UndefinedTypeVariableInBindingTypeError = Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"+_UndefinedTypeVariableInBindingTypeError_location = Core.Name "location"+_UndefinedTypeVariableInBindingTypeError_name = Core.Name "name"+-- | A type variable in a lambda domain annotation that is not bound in scope+data UndefinedTypeVariableInLambdaDomainError =+  UndefinedTypeVariableInLambdaDomainError {+    -- | The path to the lambda within the term+    undefinedTypeVariableInLambdaDomainErrorLocation :: Paths.SubtermPath,+    -- | The name of the undefined type variable+    undefinedTypeVariableInLambdaDomainErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UndefinedTypeVariableInLambdaDomainError = Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"+_UndefinedTypeVariableInLambdaDomainError_location = Core.Name "location"+_UndefinedTypeVariableInLambdaDomainError_name = Core.Name "name"+-- | A type variable in a type application term that is not bound in scope+data UndefinedTypeVariableInTypeApplicationError =+  UndefinedTypeVariableInTypeApplicationError {+    -- | The path to the type application within the term+    undefinedTypeVariableInTypeApplicationErrorLocation :: Paths.SubtermPath,+    -- | The name of the undefined type variable+    undefinedTypeVariableInTypeApplicationErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UndefinedTypeVariableInTypeApplicationError = Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"+_UndefinedTypeVariableInTypeApplicationError_location = Core.Name "location"+_UndefinedTypeVariableInTypeApplicationError_name = Core.Name "name"+-- | An unexpected term variant was encountered+data UnexpectedTermVariantError =+  UnexpectedTermVariantError {+    -- | The expected term variant+    unexpectedTermVariantErrorExpectedVariant :: Variants.TermVariant,+    -- | The actual term that was encountered+    unexpectedTermVariantErrorActualTerm :: Core.Term}+  deriving (Eq, Ord, Read, Show)+_UnexpectedTermVariantError = Core.Name "hydra.error.core.UnexpectedTermVariantError"+_UnexpectedTermVariantError_expectedVariant = Core.Name "expectedVariant"+_UnexpectedTermVariantError_actualTerm = Core.Name "actualTerm"+-- | An unexpected type variant was encountered+data UnexpectedTypeVariantError =+  UnexpectedTypeVariantError {+    -- | The expected type variant+    unexpectedTypeVariantErrorExpectedVariant :: Variants.TypeVariant,+    -- | The actual type that was encountered+    unexpectedTypeVariantErrorActualType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_UnexpectedTypeVariantError = Core.Name "hydra.error.core.UnexpectedTypeVariantError"+_UnexpectedTypeVariantError_expectedVariant = Core.Name "expectedVariant"+_UnexpectedTypeVariantError_actualType = Core.Name "actualType"+-- | A primitive function reference to a name not in the known primitive registry+data UnknownPrimitiveNameError =+  UnknownPrimitiveNameError {+    -- | The path to the primitive reference within the term+    unknownPrimitiveNameErrorLocation :: Paths.SubtermPath,+    -- | The unknown primitive name+    unknownPrimitiveNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UnknownPrimitiveNameError = Core.Name "hydra.error.core.UnknownPrimitiveNameError"+_UnknownPrimitiveNameError_location = Core.Name "location"+_UnknownPrimitiveNameError_name = Core.Name "name"+-- | An application of an identity lambda to an argument, which simplifies to the argument (optional)+data UnnecessaryIdentityApplicationError =+  UnnecessaryIdentityApplicationError {+    -- | The path to the identity application within the term+    unnecessaryIdentityApplicationErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_UnnecessaryIdentityApplicationError = Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"+_UnnecessaryIdentityApplicationError_location = Core.Name "location"+-- | A term variable whose type is not known in the current scope+data UntypedTermVariableError =+  UntypedTermVariableError {+    -- | The path to the untyped variable within the term+    untypedTermVariableErrorLocation :: Paths.SubtermPath,+    -- | The name of the untyped variable+    untypedTermVariableErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_UntypedTermVariableError = Core.Name "hydra.error.core.UntypedTermVariableError"+_UntypedTermVariableError_location = Core.Name "location"+_UntypedTermVariableError_name = Core.Name "name"+-- | TypeVoid appearing in a position where no value can be constructed, such as a record field, list element, map key/value, set element, pair component, or function codomain (optional)+data VoidInNonBottomPositionError =+  VoidInNonBottomPositionError {+    -- | The path to the void type in a non-bottom position+    voidInNonBottomPositionErrorLocation :: Paths.SubtermPath}+  deriving (Eq, Ord, Read, Show)+_VoidInNonBottomPositionError = Core.Name "hydra.error.core.VoidInNonBottomPositionError"+_VoidInNonBottomPositionError_location = Core.Name "location"
+ src/main/haskell/Hydra/Error/Packaging.hs view
@@ -0,0 +1,163 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Error types for module and package validation++module Hydra.Error.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Util as Util+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | A module name which, when mapped to a target language's directory or package structure, conflicts with another module's mapped name. For example, hydra.foo.bar and hydra.fooBar might both map to the same directory in a case-insensitive filesystem.+data ConflictingModuleNameError =+  ConflictingModuleNameError {+    -- | The first module name+    conflictingModuleNameErrorFirst :: Packaging.ModuleName,+    -- | The second module name that conflicts with the first+    conflictingModuleNameErrorSecond :: Packaging.ModuleName}+  deriving (Eq, Ord, Read, Show)+_ConflictingModuleNameError = Core.Name "hydra.error.packaging.ConflictingModuleNameError"+_ConflictingModuleNameError_first = Core.Name "first"+_ConflictingModuleNameError_second = Core.Name "second"+-- | A union type variant name which, when capitalized and concatenated with its type name, conflicts with another type definition name. For example, a union type Foo with a variant bar produces FooBar, which conflicts with an existing type definition FooBar. This is currently a problem only for the Haskell target.+data ConflictingVariantNameError =+  ConflictingVariantNameError {+    -- | The name of the module containing the conflict+    conflictingVariantNameErrorModuleName :: Packaging.ModuleName,+    -- | The name of the union type+    conflictingVariantNameErrorTypeName :: Core.Name,+    -- | The name of the variant field causing the conflict+    conflictingVariantNameErrorVariantName :: Core.Name,+    -- | The name of the other type definition that conflicts with the generated constructor name+    conflictingVariantNameErrorConflictingName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_ConflictingVariantNameError = Core.Name "hydra.error.packaging.ConflictingVariantNameError"+_ConflictingVariantNameError_moduleName = Core.Name "moduleName"+_ConflictingVariantNameError_typeName = Core.Name "typeName"+_ConflictingVariantNameError_variantName = Core.Name "variantName"+_ConflictingVariantNameError_conflictingName = Core.Name "conflictingName"+-- | A definition whose name does not have the module's name as a prefix. If the module name is foo.bar, all definition names must have the form foo.bar.quux.+data DefinitionNotInModuleNameError =+  DefinitionNotInModuleNameError {+    -- | The name of the module+    definitionNotInModuleNameErrorModuleName :: Packaging.ModuleName,+    -- | The definition name that does not match the module name+    definitionNotInModuleNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_DefinitionNotInModuleNameError = Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"+_DefinitionNotInModuleNameError_moduleName = Core.Name "moduleName"+_DefinitionNotInModuleNameError_name = Core.Name "name"+-- | Two consecutive definitions in a module's definitions list that are not in alphabetical order by local name. Hydra requires definitions to appear in lexicographic ASCII order of their local names.+data DefinitionsOutOfOrderError =+  DefinitionsOutOfOrderError {+    -- | The name of the module containing the misordered definitions+    definitionsOutOfOrderErrorModuleName :: Packaging.ModuleName,+    -- | The definition that appears first in the list+    definitionsOutOfOrderErrorPrecedingName :: Core.Name,+    -- | The definition that appears next, but should sort earlier than precedingName+    definitionsOutOfOrderErrorFollowingName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_DefinitionsOutOfOrderError = Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"+_DefinitionsOutOfOrderError_moduleName = Core.Name "moduleName"+_DefinitionsOutOfOrderError_precedingName = Core.Name "precedingName"+_DefinitionsOutOfOrderError_followingName = Core.Name "followingName"+-- | Two or more definitions in the same module share the same name+data DuplicateDefinitionNameError =+  DuplicateDefinitionNameError {+    -- | The name of the module containing the duplicates+    duplicateDefinitionNameErrorModuleName :: Packaging.ModuleName,+    -- | The duplicated definition name+    duplicateDefinitionNameErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_DuplicateDefinitionNameError = Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"+_DuplicateDefinitionNameError_moduleName = Core.Name "moduleName"+_DuplicateDefinitionNameError_name = Core.Name "name"+-- | Two or more modules in the same package share the same name+data DuplicateModuleNameError =+  DuplicateModuleNameError {+    -- | The duplicated module name+    duplicateModuleNameErrorModuleName :: Packaging.ModuleName}+  deriving (Eq, Ord, Read, Show)+_DuplicateModuleNameError = Core.Name "hydra.error.packaging.DuplicateModuleNameError"+_DuplicateModuleNameError_moduleName = Core.Name "moduleName"+-- | A definition whose local name does not match the expected naming convention. Term-level definitions must be camelCase; type-level definitions must be PascalCase.+data InvalidDefinitionNameError =+  InvalidDefinitionNameError {+    -- | The name of the module containing the definition+    invalidDefinitionNameErrorModuleName :: Packaging.ModuleName,+    -- | The definition name that violates the naming convention+    invalidDefinitionNameErrorName :: Core.Name,+    -- | The case convention the name should have followed (camel for term-level, pascal for type-level)+    invalidDefinitionNameErrorExpectedConvention :: Util.CaseConvention}+  deriving (Eq, Ord, Read, Show)+_InvalidDefinitionNameError = Core.Name "hydra.error.packaging.InvalidDefinitionNameError"+_InvalidDefinitionNameError_moduleName = Core.Name "moduleName"+_InvalidDefinitionNameError_name = Core.Name "name"+_InvalidDefinitionNameError_expectedConvention = Core.Name "expectedConvention"+-- | An error indicating that a module is invalid+data InvalidModuleError =+  -- | A union variant name that conflicts with another type definition when mapped to a target language+  InvalidModuleErrorConflictingVariantName ConflictingVariantNameError |+  -- | A definition whose name does not have the module's name as a prefix+  InvalidModuleErrorDefinitionNotInModuleName DefinitionNotInModuleNameError |+  -- | Two consecutive definitions in the definitions list that are not in alphabetical order+  InvalidModuleErrorDefinitionsOutOfOrder DefinitionsOutOfOrderError |+  -- | Two or more definitions in the same module share the same name+  InvalidModuleErrorDuplicateDefinitionName DuplicateDefinitionNameError |+  -- | A definition whose local name does not match the expected naming convention+  InvalidModuleErrorInvalidDefinitionName InvalidDefinitionNameError |+  -- | A module whose name does not match the module-name naming convention+  InvalidModuleErrorInvalidModuleNameConvention InvalidModuleNameConventionError |+  -- | A top-level definition lacking a description annotation+  InvalidModuleErrorMissingDocumentation MissingDocumentationError+  deriving (Eq, Ord, Read, Show)+_InvalidModuleError = Core.Name "hydra.error.packaging.InvalidModuleError"+_InvalidModuleError_conflictingVariantName = Core.Name "conflictingVariantName"+_InvalidModuleError_definitionNotInModuleName = Core.Name "definitionNotInModuleName"+_InvalidModuleError_definitionsOutOfOrder = Core.Name "definitionsOutOfOrder"+_InvalidModuleError_duplicateDefinitionName = Core.Name "duplicateDefinitionName"+_InvalidModuleError_invalidDefinitionName = Core.Name "invalidDefinitionName"+_InvalidModuleError_invalidModuleNameConvention = Core.Name "invalidModuleNameConvention"+_InvalidModuleError_missingDocumentation = Core.Name "missingDocumentation"+-- | A module whose name does not match the dotted-lowercase naming convention. Module names must be dot-separated lowercase segments, each starting with a letter, e.g. hydra.core or hydra.lib.lists.+data InvalidModuleNameConventionError =+  InvalidModuleNameConventionError {+    -- | The module name that violates the convention+    invalidModuleNameConventionErrorModuleName :: Packaging.ModuleName}+  deriving (Eq, Ord, Read, Show)+_InvalidModuleNameConventionError = Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"+_InvalidModuleNameConventionError_moduleName = Core.Name "moduleName"+-- | An error indicating that a package is invalid+data InvalidPackageError =+  -- | Two module names that conflict when mapped to a target language+  InvalidPackageErrorConflictingModuleName ConflictingModuleNameError |+  -- | Two or more modules in the same package share the same name+  InvalidPackageErrorDuplicateModuleName DuplicateModuleNameError |+  -- | A module within the package is invalid+  InvalidPackageErrorInvalidModule InvalidModuleError |+  -- | A package whose name does not match the package-name naming convention+  InvalidPackageErrorInvalidPackageName InvalidPackageNameError+  deriving (Eq, Ord, Read, Show)+_InvalidPackageError = Core.Name "hydra.error.packaging.InvalidPackageError"+_InvalidPackageError_conflictingModuleName = Core.Name "conflictingModuleName"+_InvalidPackageError_duplicateModuleName = Core.Name "duplicateModuleName"+_InvalidPackageError_invalidModule = Core.Name "invalidModule"+_InvalidPackageError_invalidPackageName = Core.Name "invalidPackageName"+-- | A package whose name does not match the hyphen-separated lowercase naming convention. Package names must be hyphen-separated lowercase segments, each starting with a letter, e.g. hydra-kernel or hydra-python.+data InvalidPackageNameError =+  InvalidPackageNameError {+    -- | The package name that violates the convention+    invalidPackageNameErrorPackageName :: Packaging.PackageName}+  deriving (Eq, Ord, Read, Show)+_InvalidPackageNameError = Core.Name "hydra.error.packaging.InvalidPackageNameError"+_InvalidPackageNameError_packageName = Core.Name "packageName"+-- | A top-level definition whose term (or type, for type definitions) lacks a description annotation. Every definition in a Hydra module is expected to be wrapped in a doc "..." annotation at its top level.+data MissingDocumentationError =+  MissingDocumentationError {+    -- | The name of the module containing the undocumented definition+    missingDocumentationErrorModuleName :: Packaging.ModuleName,+    -- | The name of the undocumented definition+    missingDocumentationErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_MissingDocumentationError = Core.Name "hydra.error.packaging.MissingDocumentationError"+_MissingDocumentationError_moduleName = Core.Name "moduleName"+_MissingDocumentationError_name = Core.Name "name"
+ src/main/haskell/Hydra/Errors.hs view
@@ -0,0 +1,229 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Top-level error types for the Hydra kernel++module Hydra.Errors where+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Paths as Paths+import qualified Hydra.Typing as Typing+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | An error that occurred during decoding of a term+newtype DecodingError =+  DecodingError {+    unDecodingError :: String}+  deriving (Eq, Ord, Read, Show)+_DecodingError = Core.Name "hydra.errors.DecodingError"+-- | An empty list was encountered where a non-empty list was required+type EmptyListError = ()+_EmptyListError = Core.Name "hydra.errors.EmptyListError"+-- | An error of any kind, with kernel errors particularly differentiated+data Error =+  -- | A type checking error+  ErrorChecking Checking.CheckingError |+  -- | An error that occurred during decoding of a term+  ErrorDecoding DecodingError |+  -- | A duplicate binding name error+  ErrorDuplicateBinding ErrorCore.DuplicateBindingError |+  -- | A duplicate field name error+  ErrorDuplicateField ErrorCore.DuplicateFieldError |+  -- | An error that occurred while extracting a value from a term+  ErrorExtraction ExtractionError |+  -- | A type inference error+  ErrorInference InferenceError |+  -- | A literal value validation error+  ErrorInvalidLiteral ErrorCore.InvalidLiteralError |+  -- | Any other error+  ErrorOther OtherError |+  -- | A name-resolution error+  ErrorResolution ResolutionError |+  -- | A reference to an undefined field+  ErrorUndefinedField ErrorCore.UndefinedFieldError |+  -- | A reference to an undefined term variable+  ErrorUndefinedTermVariable ErrorCore.UndefinedTermVariableError |+  -- | A term variable whose type is not known+  ErrorUntypedTermVariable ErrorCore.UntypedTermVariableError |+  -- | An unexpected term variant+  ErrorUnexpectedTermVariant ErrorCore.UnexpectedTermVariantError |+  -- | An unexpected type variant+  ErrorUnexpectedTypeVariant ErrorCore.UnexpectedTypeVariantError |+  -- | A type unification error+  ErrorUnification UnificationError+  deriving (Eq, Ord, Read, Show)+_Error = Core.Name "hydra.errors.Error"+_Error_checking = Core.Name "checking"+_Error_decoding = Core.Name "decoding"+_Error_duplicateBinding = Core.Name "duplicateBinding"+_Error_duplicateField = Core.Name "duplicateField"+_Error_extraction = Core.Name "extraction"+_Error_inference = Core.Name "inference"+_Error_invalidLiteral = Core.Name "invalidLiteral"+_Error_other = Core.Name "other"+_Error_resolution = Core.Name "resolution"+_Error_undefinedField = Core.Name "undefinedField"+_Error_undefinedTermVariable = Core.Name "undefinedTermVariable"+_Error_untypedTermVariable = Core.Name "untypedTermVariable"+_Error_unexpectedTermVariant = Core.Name "unexpectedTermVariant"+_Error_unexpectedTypeVariant = Core.Name "unexpectedTypeVariant"+_Error_unification = Core.Name "unification"+-- | An error that occurred while extracting a typed value from a term+data ExtractionError =+  -- | An empty list was encountered where a non-empty list was required+  ExtractionErrorEmptyList EmptyListError |+  -- | Multiple let bindings were found with the same name+  ExtractionErrorMultipleBindings MultipleBindingsError |+  -- | Multiple record fields were found with the same field name+  ExtractionErrorMultipleFields MultipleFieldsError |+  -- | No field with the expected name was found in a record+  ExtractionErrorNoMatchingField NoMatchingFieldError |+  -- | No let binding with the expected name was found+  ExtractionErrorNoSuchBinding NoSuchBindingError |+  -- | A case statement did not contain enough cases to match the target+  ExtractionErrorNotEnoughCases NotEnoughCasesError |+  -- | A term, type, literal, or other value had an unexpected shape+  ExtractionErrorUnexpectedShape UnexpectedShapeError+  deriving (Eq, Ord, Read, Show)+_ExtractionError = Core.Name "hydra.errors.ExtractionError"+_ExtractionError_emptyList = Core.Name "emptyList"+_ExtractionError_multipleBindings = Core.Name "multipleBindings"+_ExtractionError_multipleFields = Core.Name "multipleFields"+_ExtractionError_noMatchingField = Core.Name "noMatchingField"+_ExtractionError_noSuchBinding = Core.Name "noSuchBinding"+_ExtractionError_notEnoughCases = Core.Name "notEnoughCases"+_ExtractionError_unexpectedShape = Core.Name "unexpectedShape"+-- | An error that occurred during type inference+data InferenceError =+  -- | A type checking error encountered during inference+  InferenceErrorChecking Checking.CheckingError |+  -- | A generic inference error carrying a message and a subterm path. Placeholder arm; sites should migrate to typed variants.+  InferenceErrorOther OtherInferenceError |+  -- | A unification failure encountered while inferring types+  InferenceErrorUnification UnificationInferenceError+  deriving (Eq, Ord, Read, Show)+_InferenceError = Core.Name "hydra.errors.InferenceError"+_InferenceError_checking = Core.Name "checking"+_InferenceError_other = Core.Name "other"+_InferenceError_unification = Core.Name "unification"+-- | Multiple let bindings with the same name were found+data MultipleBindingsError =+  MultipleBindingsError {+    -- | The binding name which was duplicated+    multipleBindingsErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_MultipleBindingsError = Core.Name "hydra.errors.MultipleBindingsError"+_MultipleBindingsError_name = Core.Name "name"+-- | Multiple fields with the same name were found in a record+data MultipleFieldsError =+  MultipleFieldsError {+    -- | The field name which appeared more than once+    multipleFieldsErrorFieldName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_MultipleFieldsError = Core.Name "hydra.errors.MultipleFieldsError"+_MultipleFieldsError_fieldName = Core.Name "fieldName"+-- | No field with the expected name was present+data NoMatchingFieldError =+  NoMatchingFieldError {+    -- | The field name which was not found+    noMatchingFieldErrorFieldName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_NoMatchingFieldError = Core.Name "hydra.errors.NoMatchingFieldError"+_NoMatchingFieldError_fieldName = Core.Name "fieldName"+-- | No let binding with the expected name was present+data NoSuchBindingError =+  NoSuchBindingError {+    -- | The binding name which was not found+    noSuchBindingErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_NoSuchBindingError = Core.Name "hydra.errors.NoSuchBindingError"+_NoSuchBindingError_name = Core.Name "name"+-- | No primitive function with the expected name was registered in the graph+data NoSuchPrimitiveError =+  NoSuchPrimitiveError {+    -- | The primitive name which was not found+    noSuchPrimitiveErrorName :: Core.Name}+  deriving (Eq, Ord, Read, Show)+_NoSuchPrimitiveError = Core.Name "hydra.errors.NoSuchPrimitiveError"+_NoSuchPrimitiveError_name = Core.Name "name"+-- | A case statement was missing a case for the requested variant+type NotEnoughCasesError = ()+_NotEnoughCasesError = Core.Name "hydra.errors.NotEnoughCasesError"+-- | Any other error+newtype OtherError =+  OtherError {+    unOtherError :: String}+  deriving (Eq, Ord, Read, Show)+_OtherError = Core.Name "hydra.errors.OtherError"+-- | A generic inference error: message + subterm path+data OtherInferenceError =+  OtherInferenceError {+    -- | The subterm path at which the error was observed+    otherInferenceErrorPath :: Paths.SubtermPath,+    -- | A human-readable error message+    otherInferenceErrorMessage :: String}+  deriving (Eq, Ord, Read, Show)+_OtherInferenceError = Core.Name "hydra.errors.OtherInferenceError"+_OtherInferenceError_path = Core.Name "path"+_OtherInferenceError_message = Core.Name "message"+-- | A generic resolution error: message+newtype OtherResolutionError =+  OtherResolutionError {+    unOtherResolutionError :: String}+  deriving (Eq, Ord, Read, Show)+_OtherResolutionError = Core.Name "hydra.errors.OtherResolutionError"+-- | An error that occurred while resolving a name, primitive, or record/union shape in a graph+data ResolutionError =+  -- | No binding with the expected name was found in the graph+  ResolutionErrorNoSuchBinding NoSuchBindingError |+  -- | No primitive function with the expected name was found in the graph+  ResolutionErrorNoSuchPrimitive NoSuchPrimitiveError |+  -- | No field with the expected name was present in a record or case statement+  ResolutionErrorNoMatchingField NoMatchingFieldError |+  -- | A generic resolution error carrying a message+  ResolutionErrorOther OtherResolutionError |+  -- | A term had a shape other than the one expected (e.g. a record, an injection)+  ResolutionErrorUnexpectedShape UnexpectedShapeError+  deriving (Eq, Ord, Read, Show)+_ResolutionError = Core.Name "hydra.errors.ResolutionError"+_ResolutionError_noSuchBinding = Core.Name "noSuchBinding"+_ResolutionError_noSuchPrimitive = Core.Name "noSuchPrimitive"+_ResolutionError_noMatchingField = Core.Name "noMatchingField"+_ResolutionError_other = Core.Name "other"+_ResolutionError_unexpectedShape = Core.Name "unexpectedShape"+-- | A term, type, literal, or related value had a shape other than the one expected+data UnexpectedShapeError =+  UnexpectedShapeError {+    -- | A description of the expected shape+    unexpectedShapeErrorExpected :: String,+    -- | A description of the shape actually encountered+    unexpectedShapeErrorActual :: String}+  deriving (Eq, Ord, Read, Show)+_UnexpectedShapeError = Core.Name "hydra.errors.UnexpectedShapeError"+_UnexpectedShapeError_expected = Core.Name "expected"+_UnexpectedShapeError_actual = Core.Name "actual"+-- | An error that occurred during type unification+data UnificationError =+  UnificationError {+    -- | The left-hand type in the unification+    unificationErrorLeftType :: Core.Type,+    -- | The right-hand type in the unification+    unificationErrorRightType :: Core.Type,+    -- | A human-readable error message+    unificationErrorMessage :: String}+  deriving (Eq, Ord, Read, Show)+_UnificationError = Core.Name "hydra.errors.UnificationError"+_UnificationError_leftType = Core.Name "leftType"+_UnificationError_rightType = Core.Name "rightType"+_UnificationError_message = Core.Name "message"+-- | A unification failure at a specific subterm locus during inference+data UnificationInferenceError =+  UnificationInferenceError {+    -- | The subterm path at which the unification failure was observed+    unificationInferenceErrorPath :: Paths.SubtermPath,+    -- | The underlying unification error+    unificationInferenceErrorCause :: UnificationError}+  deriving (Eq, Ord, Read, Show)+_UnificationInferenceError = Core.Name "hydra.errors.UnificationInferenceError"+_UnificationInferenceError_path = Core.Name "path"+_UnificationInferenceError_cause = Core.Name "cause"
+ src/main/haskell/Hydra/Extract/Core.hs view
@@ -0,0 +1,579 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Extraction and validation for hydra.core types++module Hydra.Extract.Core where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.ByteString as B+import qualified Data.Int as I+import qualified Data.Map as M+import qualified Data.Set as S+-- | Extract an arbitrary-precision integer value from a term+bigint :: Graph.Graph -> Core.Term -> Either Errors.Error Integer+bigint graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> bigintValue i))+-- | Extract a bigint value from an IntegerValue+bigintValue :: Core.IntegerValue -> Either Errors.Error Integer+bigintValue v =+    case v of+      Core.IntegerValueBigint v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "bigint",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract a binary data value from a term+binary :: Graph.Graph -> Core.Term -> Either Errors.Error B.ByteString+binary graph t = Eithers.bind (literal graph t) (\l -> binaryLiteral l)+-- | Extract a binary literal from a Literal value+binaryLiteral :: Core.Literal -> Either Errors.Error B.ByteString+binaryLiteral v =+    case v of+      Core.LiteralBinary v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "binary",+        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+-- | Extract a boolean value from a term+boolean :: Graph.Graph -> Core.Term -> Either Errors.Error Bool+boolean graph t = Eithers.bind (literal graph t) (\l -> booleanLiteral l)+-- | Extract a boolean literal from a Literal value+booleanLiteral :: Core.Literal -> Either Errors.Error Bool+booleanLiteral v =+    case v of+      Core.LiteralBoolean v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "boolean",+        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+-- | Extract a specific case handler from a case statement term+caseField :: Core.Name -> String -> Graph.Graph -> Core.Term -> Either Errors.Error Core.CaseAlternative+caseField name n graph term =++      let fieldName = Core.Name n+      in (Eithers.bind (cases name graph term) (\cs ->+        let matching =+                Lists.find (\f -> Equality.equal (Core.unName (Core.caseAlternativeName f)) (Core.unName fieldName)) (Core.caseStatementCases cs)+        in (Optionals.cases matching (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "matching case",+          Errors.unexpectedShapeErrorActual = "no matching case"})))) (\mf -> Right mf))))+-- | Extract case statement from a term+cases :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error Core.CaseStatement+cases name graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermCases v0 -> Logic.ifElse (Equality.equal (Core.unName (Core.caseStatementTypeName v0)) (Core.unName name)) (Right v0) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = (Strings.cat2 "case statement for type " (Core.unName name)),+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "case statement",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract an arbitrary-precision decimal value from a term+decimal :: Graph.Graph -> Core.Term -> Either Errors.Error Sci.Scientific+decimal graph t = Eithers.bind (literal graph t) (\l -> decimalLiteral l)+-- | Extract a decimal literal from a Literal value+decimalLiteral :: Core.Literal -> Either Errors.Error Sci.Scientific+decimalLiteral v =+    case v of+      Core.LiteralDecimal v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "decimal",+        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+-- | Decode an Either value using the provided left and right decoders+decodeEither :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Either t0 t1)+decodeEither leftDecoder rightDecoder g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermEither v0 -> Eithers.either (\lv -> Eithers.map (\x -> Left x) (leftDecoder g lv)) (\rv -> Eithers.map (\x -> Right x) (rightDecoder g rv)) v0+      _ -> Left (Errors.DecodingError "expected either value"))+-- | Decode a list of elements using the provided element decoder+decodeList :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError [t0]+decodeList elemDecoder g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermList v0 -> Eithers.mapList (elemDecoder g) v0+      _ -> Left (Errors.DecodingError "expected list"))+-- | Decode a Map using the provided key and value decoders+decodeMap :: Ord t0 => ((Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (M.Map t0 t1))+decodeMap keyDecoder valDecoder g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermMap v0 -> Eithers.map Maps.fromList (Eithers.mapList (\kv -> Eithers.bind (keyDecoder g (Pairs.first kv)) (\k -> Eithers.map (\v -> (k, v)) (valDecoder g (Pairs.second kv)))) (Maps.toList v0))+      _ -> Left (Errors.DecodingError "expected map"))+-- | Decode a Maybe value using the provided element decoder+decodeMaybe :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Maybe t0)+decodeMaybe elemDecoder g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermOptional v0 -> Eithers.mapOptional (elemDecoder g) v0+      _ -> Left (Errors.DecodingError "expected optional value"))+-- | Decode a Pair using the provided first and second decoders+decodePair :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> (Graph.Graph -> Core.Term -> Either Errors.DecodingError t1) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (t0, t1)+decodePair firstDecoder secondDecoder g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermPair v0 -> Eithers.bind (firstDecoder g (Pairs.first v0)) (\f -> Eithers.map (\s -> (f, s)) (secondDecoder g (Pairs.second v0)))+      _ -> Left (Errors.DecodingError "expected pair"))+-- | Decode a Set using the provided element decoder+decodeSet :: Ord t0 => ((Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (S.Set t0))+decodeSet elemDecoder g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermSet v0 -> Eithers.map Sets.fromList (Eithers.mapList (elemDecoder g) (Sets.toList v0))+      _ -> Left (Errors.DecodingError "expected set"))+-- | Decode a unit value+decodeUnit :: Graph.Graph -> Core.Term -> Either Errors.DecodingError ()+decodeUnit g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermUnit -> Right ()+      _ -> Left (Errors.DecodingError "expected a unit value"))+-- | Decode a wrapped value using the provided body decoder+decodeWrapped :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError t0) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError t0+decodeWrapped bodyDecoder g term =+    Eithers.bind (stripWithDecodingError g term) (\stripped -> case stripped of+      Core.TermWrap v0 -> bodyDecoder g (Core.wrappedTermBody v0)+      _ -> Left (Errors.DecodingError "expected wrapped value"))+-- | Extract an either value from a term, applying functions to the left and right values+eitherTerm :: (Core.Term -> Either Errors.Error t0) -> (Core.Term -> Either Errors.Error t1) -> Graph.Graph -> Core.Term -> Either Errors.Error (Either t0 t1)+eitherTerm leftFun rightFun graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermEither v0 -> Eithers.either (\l -> Eithers.map (\x -> Left x) (leftFun l)) (\r -> Eithers.map (\x -> Right x) (rightFun r)) v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "either value",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract the left and right types from an either type+eitherType :: Core.Type -> Either Errors.Error Core.EitherType+eitherType typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeEither v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "either type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Extract a field value from a list of fields+field :: Core.Name -> (Core.Term -> Either Errors.Error t0) -> Graph.Graph -> [Core.Field] -> Either Errors.Error t0+field fname mapping graph fields =++      let matchingFields = Lists.filter (\f -> Equality.equal (Core.unName (Core.fieldName f)) (Core.unName fname)) fields+          noMatchErr =+                  Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+                    Errors.unexpectedShapeErrorExpected = (Strings.cat2 "field " (Core.unName fname)),+                    Errors.unexpectedShapeErrorActual = "no matching field"})))+      in (Logic.ifElse (Lists.null matchingFields) noMatchErr (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Optionals.cases (Lists.maybeHead matchingFields) noMatchErr (\mf -> Eithers.bind (Lexical.stripAndDereferenceTerm graph (Core.fieldTerm mf)) (\stripped -> mapping stripped))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "single field",+        Errors.unexpectedShapeErrorActual = (Strings.cat2 "multiple fields named " (Core.unName fname))}))))))+-- | Extract a 32-bit floating-point value from a term+float32 :: Graph.Graph -> Core.Term -> Either Errors.Error Float+float32 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (floatLiteral l) (\f -> float32Value f))+-- | Extract a float32 value from a FloatValue+float32Value :: Core.FloatValue -> Either Errors.Error Float+float32Value v =+    case v of+      Core.FloatValueFloat32 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "float32",+        Errors.unexpectedShapeErrorActual = (ShowCore.float v)})))+-- | Extract a 64-bit floating-point value from a term+float64 :: Graph.Graph -> Core.Term -> Either Errors.Error Double+float64 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (floatLiteral l) (\f -> float64Value f))+-- | Extract a float64 value from a FloatValue+float64Value :: Core.FloatValue -> Either Errors.Error Double+float64Value v =+    case v of+      Core.FloatValueFloat64 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "float64",+        Errors.unexpectedShapeErrorActual = (ShowCore.float v)})))+-- | Extract a floating-point literal from a Literal value+floatLiteral :: Core.Literal -> Either Errors.Error Core.FloatValue+floatLiteral lit =+    case lit of+      Core.LiteralFloat v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "floating-point value",+        Errors.unexpectedShapeErrorActual = (ShowCore.literal lit)})))+-- | Extract a float value from a term+floatValue :: Graph.Graph -> Core.Term -> Either Errors.Error Core.FloatValue+floatValue graph t = Eithers.bind (literal graph t) (\l -> floatLiteral l)+-- | Extract a function type from a type+functionType :: Core.Type -> Either Errors.Error Core.FunctionType+functionType typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeFunction v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "function type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Extract a field from a union term+injection :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Field+injection expected graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermInject v0 -> Logic.ifElse (Equality.equal (Core.unName (Core.injectionTypeName v0)) (Core.unName expected)) (Right (Core.injectionField v0)) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = (Strings.cat2 "injection of type " (Core.unName expected)),+        Errors.unexpectedShapeErrorActual = (Core.unName (Core.injectionTypeName v0))}))))+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "injection",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract a 16-bit signed integer value from a term+int16 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int16+int16 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> int16Value i))+-- | Extract an int16 value from an IntegerValue+int16Value :: Core.IntegerValue -> Either Errors.Error I.Int16+int16Value v =+    case v of+      Core.IntegerValueInt16 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "int16",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract a 32-bit signed integer value from a term+int32 :: Graph.Graph -> Core.Term -> Either Errors.Error Int+int32 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> int32Value i))+-- | Extract an int32 value from an IntegerValue+int32Value :: Core.IntegerValue -> Either Errors.Error Int+int32Value v =+    case v of+      Core.IntegerValueInt32 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "int32",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract a 64-bit signed integer value from a term+int64 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int64+int64 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> int64Value i))+-- | Extract an int64 value from an IntegerValue+int64Value :: Core.IntegerValue -> Either Errors.Error I.Int64+int64Value v =+    case v of+      Core.IntegerValueInt64 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "int64",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract an 8-bit signed integer value from a term+int8 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int8+int8 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> int8Value i))+-- | Extract an int8 value from an IntegerValue+int8Value :: Core.IntegerValue -> Either Errors.Error I.Int8+int8Value v =+    case v of+      Core.IntegerValueInt8 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "int8",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract an integer literal from a Literal value+integerLiteral :: Core.Literal -> Either Errors.Error Core.IntegerValue+integerLiteral lit =+    case lit of+      Core.LiteralInteger v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "integer value",+        Errors.unexpectedShapeErrorActual = (ShowCore.literal lit)})))+-- | Extract an integer value from a term+integerValue :: Graph.Graph -> Core.Term -> Either Errors.Error Core.IntegerValue+integerValue graph t = Eithers.bind (literal graph t) (\l -> integerLiteral l)+-- | Extract a lambda from a term+lambda :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Lambda+lambda graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermLambda v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "lambda",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract the body of a lambda term+lambdaBody :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+lambdaBody graph term = Eithers.map Core.lambdaBody (lambda graph term)+-- | Extract a let expression from a term+let_ :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Let+let_ graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermLet v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "let term",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract a binding with the given name from a let term+letBinding :: String -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+letBinding n graph term =++      let name = Core.Name n+      in (Eithers.bind (let_ graph term) (\letExpr ->+        let matchingBindings =+                Lists.filter (\b -> Equality.equal (Core.unName (Core.bindingName b)) (Core.unName name)) (Core.letBindings letExpr)+            noBindingErr =+                    Left (Errors.ErrorExtraction (Errors.ExtractionErrorNoSuchBinding (Errors.NoSuchBindingError {+                      Errors.noSuchBindingErrorName = name})))+        in (Logic.ifElse (Lists.null matchingBindings) noBindingErr (Logic.ifElse (Equality.equal (Lists.length matchingBindings) 1) (Optionals.cases (Lists.maybeHead matchingBindings) noBindingErr (\b -> Right (Core.bindingTerm b))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorMultipleBindings (Errors.MultipleBindingsError {+          Errors.multipleBindingsErrorName = name}))))))))+-- | Extract a list of terms from a term+list :: Graph.Graph -> Core.Term -> Either Errors.Error [Core.Term]+list graph term =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term) (\stripped -> case stripped of+      Core.TermList v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "list",+        Errors.unexpectedShapeErrorActual = (ShowCore.term stripped)}))))+-- | Extract the first element of a list term+listHead :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+listHead graph term =+    Eithers.bind (list graph term) (\l -> Optionals.cases (Lists.maybeHead l) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      Errors.unexpectedShapeErrorExpected = "non-empty list",+      Errors.unexpectedShapeErrorActual = "empty list"})))) (\h -> Right h))+-- | Extract a list of values from a term, mapping a function over each element+listOf :: (Core.Term -> Either Errors.Error t0) -> Graph.Graph -> Core.Term -> Either Errors.Error [t0]+listOf f graph term = Eithers.bind (list graph term) (\els -> Eithers.mapList f els)+-- | Extract the element type from a list type+listType :: Core.Type -> Either Errors.Error Core.Type+listType typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeList v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "list type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Extract a literal value from a term+literal :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Literal+literal graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermLiteral v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "literal",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract a map of key-value pairs from a term, mapping functions over each key and value+map :: Ord t0 => ((Core.Term -> Either Errors.Error t0) -> (Core.Term -> Either Errors.Error t1) -> Graph.Graph -> Core.Term -> Either Errors.Error (M.Map t0 t1))+map fk fv graph term0 =++      let pair =+              \kvPair ->+                let kterm = Pairs.first kvPair+                    vterm = Pairs.second kvPair+                in (Eithers.bind (fk kterm) (\kval -> Eithers.bind (fv vterm) (\vval -> Right (kval, vval))))+      in (Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+        Core.TermMap v0 -> Eithers.map Maps.fromList (Eithers.mapList pair (Maps.toList v0))+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "map",+          Errors.unexpectedShapeErrorActual = (ShowCore.term term)})))))+-- | Extract the key and value types from a map type+mapType :: Core.Type -> Either Errors.Error Core.MapType+mapType typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeMap v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "map type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Ensure a function has the expected number of arguments+nArgs :: Core.Name -> Int -> [t0] -> Either Errors.Error ()+nArgs name n args =+    Logic.ifElse (Equality.equal (Lists.length args) n) (Right ()) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      Errors.unexpectedShapeErrorExpected = (Strings.cat [+        Literals.showInt32 n,+        " arguments to primitive ",+        (Literals.showString (Core.unName name))]),+      Errors.unexpectedShapeErrorActual = (Literals.showInt32 (Lists.length args))}))))+-- | Extract an optional value from a term, applying a function to the value if present+optionalTerm :: (Core.Term -> Either Errors.Error t0) -> Graph.Graph -> Core.Term -> Either Errors.Error (Maybe t0)+optionalTerm f graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermOptional v0 -> Optionals.cases v0 (Right Nothing) (\t -> Eithers.map Optionals.pure (f t))+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "optional value",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract the base type from an optional type+optionalType :: Core.Type -> Either Errors.Error Core.Type+optionalType typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeOptional v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "optional type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Extract a pair of values from a term, applying functions to each component+pair :: (Core.Term -> Either Errors.Error t0) -> (Core.Term -> Either Errors.Error t1) -> Graph.Graph -> Core.Term -> Either Errors.Error (t0, t1)+pair kf vf graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermPair v0 -> Eithers.bind (kf (Pairs.first v0)) (\kVal -> Eithers.bind (vf (Pairs.second v0)) (\vVal -> Right (kVal, vVal)))+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "pair",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract a record's fields from a term+record :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error [Core.Field]+record expected graph term0 =+    Eithers.bind (termRecord graph term0) (\record -> Logic.ifElse (Equality.equal (Core.recordTypeName record) expected) (Right (Core.recordFields record)) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      Errors.unexpectedShapeErrorExpected = (Strings.cat2 "record of type " (Core.unName expected)),+      Errors.unexpectedShapeErrorActual = (Core.unName (Core.recordTypeName record))})))))+-- | Extract the field types from a record type+recordType :: t0 -> Core.Type -> Either Errors.Error [Core.FieldType]+recordType ename typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeRecord v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "record type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Require a field from a record's field map and decode it+requireField :: String -> (t0 -> t1 -> Either Errors.DecodingError t2) -> M.Map Core.Name t1 -> t0 -> Either Errors.DecodingError t2+requireField fieldName decoder fieldMap g =+    Optionals.cases (Maps.lookup (Core.Name fieldName) fieldMap) (Left (Errors.DecodingError (Strings.cat [+      "missing field ",+      fieldName,+      " in record"]))) (\fieldTerm -> decoder g fieldTerm)+-- | Extract a set of terms from a term+set :: Graph.Graph -> Core.Term -> Either Errors.Error (S.Set Core.Term)+set graph term =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term) (\stripped -> case stripped of+      Core.TermSet v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "set",+        Errors.unexpectedShapeErrorActual = (ShowCore.term stripped)}))))+-- | Extract a set of values from a term, mapping a function over each element+setOf :: Ord t0 => ((Core.Term -> Either Errors.Error t0) -> Graph.Graph -> Core.Term -> Either Errors.Error (S.Set t0))+setOf f graph term = Eithers.bind (set graph term) (\els -> Eithers.mapSet f els)+-- | Extract the element type from a set type+setType :: Core.Type -> Either Errors.Error Core.Type+setType typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeSet v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "set type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Extract a string value from a term+string :: Graph.Graph -> Core.Term -> Either Errors.Error String+string graph t = Eithers.bind (literal graph t) (\l -> stringLiteral l)+-- | Extract a string literal from a Literal value+stringLiteral :: Core.Literal -> Either Errors.Error String+stringLiteral v =+    case v of+      Core.LiteralString v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "string",+        Errors.unexpectedShapeErrorActual = (ShowCore.literal v)})))+-- | Strip annotations and dereference variables, returning Either DecodingError Term+stripWithDecodingError :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Core.Term+stripWithDecodingError g term =+    Eithers.bimap (\_e -> Errors.DecodingError (ShowErrors.error _e)) (\x -> x) (Lexical.stripAndDereferenceTermEither g term)+-- | Extract a record from a term+termRecord :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Record+termRecord graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermRecord v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "record",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Convert a Record's fields to a Map from Name to Term+toFieldMap :: Core.Record -> M.Map Core.Name Core.Term+toFieldMap record = Maps.fromList (Lists.map (\f -> (Core.fieldName f, (Core.fieldTerm f))) (Core.recordFields record))+-- | Extract a 16-bit unsigned integer value from a term+uint16 :: Graph.Graph -> Core.Term -> Either Errors.Error Int+uint16 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> uint16Value i))+-- | Extract a uint16 value from an IntegerValue+uint16Value :: Core.IntegerValue -> Either Errors.Error Int+uint16Value v =+    case v of+      Core.IntegerValueUint16 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "uint16",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract a 32-bit unsigned integer value from a term+uint32 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int64+uint32 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> uint32Value i))+-- | Extract a uint32 value from an IntegerValue+uint32Value :: Core.IntegerValue -> Either Errors.Error I.Int64+uint32Value v =+    case v of+      Core.IntegerValueUint32 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "uint32",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract a 64-bit unsigned integer value from a term+uint64 :: Graph.Graph -> Core.Term -> Either Errors.Error Integer+uint64 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> uint64Value i))+-- | Extract a uint64 value from an IntegerValue+uint64Value :: Core.IntegerValue -> Either Errors.Error Integer+uint64Value v =+    case v of+      Core.IntegerValueUint64 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "uint64",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract an 8-bit unsigned integer value from a term+uint8 :: Graph.Graph -> Core.Term -> Either Errors.Error I.Int16+uint8 graph t = Eithers.bind (literal graph t) (\l -> Eithers.bind (integerLiteral l) (\i -> uint8Value i))+-- | Extract a uint8 value from an IntegerValue+uint8Value :: Core.IntegerValue -> Either Errors.Error I.Int16+uint8Value v =+    case v of+      Core.IntegerValueUint8 v0 -> Right v0+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "uint8",+        Errors.unexpectedShapeErrorActual = (ShowCore.integer v)})))+-- | Extract the field types from a union type+unionType :: t0 -> Core.Type -> Either Errors.Error [Core.FieldType]+unionType ename typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeUnion v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "union type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))+-- | Extract a unit value from a term+unit :: Core.Term -> Either Errors.Error ()+unit term =+    case term of+      Core.TermUnit -> Right ()+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "unit",+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)})))+-- | Extract a unit variant (a variant with an empty record value) from a union term+unitVariant :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Name+unitVariant tname graph term =+    Eithers.bind (injection tname graph term) (\field -> Eithers.bind (unit (Core.fieldTerm field)) (\ignored -> Right (Core.fieldName field)))+-- | Extract the wrapped value from a wrapped term+wrap :: Core.Name -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+wrap expected graph term0 =+    Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of+      Core.TermWrap v0 -> Logic.ifElse (Equality.equal (Core.unName (Core.wrappedTermTypeName v0)) (Core.unName expected)) (Right (Core.wrappedTermBody v0)) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = (Strings.cat2 "wrapper of type " (Core.unName expected)),+        Errors.unexpectedShapeErrorActual = (Core.unName (Core.wrappedTermTypeName v0))}))))+      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = (Strings.cat2 (Strings.cat2 "wrap(" (Core.unName expected)) ")"),+        Errors.unexpectedShapeErrorActual = (ShowCore.term term)}))))+-- | Extract the wrapped type from a wrapper type+wrappedType :: t0 -> Core.Type -> Either Errors.Error Core.Type+wrappedType ename typ =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeWrap v0 -> Right v0+        _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "wrapped type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ typ)})))
+ src/main/haskell/Hydra/Extract/Json.hs view
@@ -0,0 +1,85 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Utilities for extracting values from JSON objects++module Hydra.Extract.Json where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Extract an array from a JSON value, failing if the value is not an array+expectArray :: Model.Value -> Either String [Model.Value]+expectArray value =+    case value of+      Model.ValueArray v0 -> Right v0+      _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON array") (Strings.cat2 " but found " (showValue value)))+-- | Extract a number from a JSON value, failing if the value is not a number+expectNumber :: Model.Value -> Either String Sci.Scientific+expectNumber value =+    case value of+      Model.ValueNumber v0 -> Right v0+      _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON number") (Strings.cat2 " but found " (showValue value)))+-- | Extract an object from a JSON value as a name-keyed map, failing if the value is not an object. Field order is not preserved; lookups are by name.+expectObject :: Model.Value -> Either String (M.Map String Model.Value)+expectObject value =+    case value of+      Model.ValueObject v0 -> Right (Maps.fromList v0)+      _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON object") (Strings.cat2 " but found " (showValue value)))+-- | Extract a string from a JSON value, failing if the value is not a string+expectString :: Model.Value -> Either String String+expectString value =+    case value of+      Model.ValueString v0 -> Right v0+      _ -> Left (Strings.cat2 (Strings.cat2 "expected " "JSON string") (Strings.cat2 " but found " (showValue value)))+-- | Look up an optional field in a JSON object+opt :: Ord t0 => (t0 -> M.Map t0 t1 -> Maybe t1)+opt fname m = Maps.lookup fname m+-- | Look up an optional array field in a JSON object+optArray :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String (Maybe [Model.Value]))+optArray fname m = Optionals.cases (opt fname m) (Right Nothing) (\a -> Eithers.map (\x -> Just x) (expectArray a))+-- | Look up an optional string field in a JSON object+optString :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String (Maybe String))+optString fname m = Optionals.cases (opt fname m) (Right Nothing) (\s -> Eithers.map (\x -> Just x) (expectString s))+-- | Look up a required field in a JSON object, failing if not found+require :: Ord t0 => (t0 -> M.Map t0 t1 -> Either String t1)+require fname m =+    Optionals.cases (Maps.lookup fname m) (Left (Strings.cat [+      "required attribute ",+      (showValue fname),+      " not found"])) (\value -> Right value)+-- | Look up a required array field in a JSON object+requireArray :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String [Model.Value])+requireArray fname m = Eithers.bind (require fname m) expectArray+-- | Look up a required number field in a JSON object+requireNumber :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String Sci.Scientific)+requireNumber fname m = Eithers.bind (require fname m) expectNumber+-- | Look up a required string field in a JSON object+requireString :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String String)+requireString fname m = Eithers.bind (require fname m) expectString+-- | Show a JSON value as a string (placeholder implementation)+showValue :: t0 -> String+showValue value = "TODO: implement showValue"
+ src/main/haskell/Hydra/Extract/Util.hs view
@@ -0,0 +1,39 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Extraction and validation for hydra.util types++module Hydra.Extract.Util where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+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.Json.Model as Model+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Equality as Equality+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Extract a comparison from a term+comparison :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error Util.Comparison+comparison cx graph term =+    Eithers.bind (ExtractCore.unitVariant (Core.Name "hydra.util.Comparison") graph term) (\fname -> Logic.ifElse (Equality.equal (Core.unName fname) "equalTo") (Right Util.ComparisonEqualTo) (Logic.ifElse (Equality.equal (Core.unName fname) "lessThan") (Right Util.ComparisonLessThan) (Logic.ifElse (Equality.equal (Core.unName fname) "greaterThan") (Right Util.ComparisonGreaterThan) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      Errors.unexpectedShapeErrorExpected = "comparison",+      Errors.unexpectedShapeErrorActual = (Core.unName fname)})))))))
+ src/main/haskell/Hydra/Formatting.hs view
@@ -0,0 +1,196 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String formatting types and functions.++module Hydra.Formatting where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Chars as Chars+import qualified Hydra.Haskell.Lib.Equality as Equality+import qualified Hydra.Haskell.Lib.Lists as Lists+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | Capitalize the first letter of a string+capitalize :: String -> String+capitalize = mapFirstLetter Strings.toUpper+-- | Convert a string from one case convention to another+convertCase :: Util.CaseConvention -> Util.CaseConvention -> String -> String+convertCase from to original =++      let parts =++                let byCaps =++                          let splitOnUppercase =+                                  \acc -> \c -> Lists.concat2 (Logic.ifElse (Chars.isUpper c) [+                                    []] []) (Optionals.fromOptional acc (Optionals.map (\uc -> Lists.cons (Lists.cons c (Pairs.first uc)) (Pairs.second uc)) (Lists.uncons acc)))+                          in (Lists.map Strings.fromList (Lists.foldl splitOnUppercase [+                            []] (Lists.reverse (Strings.toList (decapitalize original)))))+                    byUnderscores = Strings.splitOn "_" original+                in case from of+                  Util.CaseConventionCamel -> byCaps+                  Util.CaseConventionPascal -> byCaps+                  Util.CaseConventionLowerSnake -> byUnderscores+                  Util.CaseConventionUpperSnake -> byUnderscores+      in case to of+        Util.CaseConventionCamel -> decapitalize (Strings.cat (Lists.map (\arg_ -> capitalize (Strings.toLower arg_)) parts))+        Util.CaseConventionPascal -> Strings.cat (Lists.map (\arg_ -> capitalize (Strings.toLower arg_)) parts)+        Util.CaseConventionLowerSnake -> Strings.intercalate "_" (Lists.map Strings.toLower parts)+        Util.CaseConventionUpperSnake -> Strings.intercalate "_" (Lists.map Strings.toUpper parts)+-- | Convert a string from camel case (possibly with underscores) to lower snake case. Splits on underscores first, then converts each part from camel case.+convertCaseCamelOrUnderscoreToLowerSnake :: String -> String+convertCaseCamelOrUnderscoreToLowerSnake s =++      let parts = Strings.splitOn "_" s+          snakeParts = Lists.map (\p -> convertCaseCamelToLowerSnake p) parts+      in (Strings.intercalate "_" snakeParts)+-- | Convert a string from camel case to lower snake case+convertCaseCamelToLowerSnake :: String -> String+convertCaseCamelToLowerSnake = convertCase Util.CaseConventionCamel Util.CaseConventionLowerSnake+-- | Convert a string from camel case to upper snake case+convertCaseCamelToUpperSnake :: String -> String+convertCaseCamelToUpperSnake = convertCase Util.CaseConventionCamel Util.CaseConventionUpperSnake+-- | Convert a string from pascal case to upper snake case+convertCasePascalToUpperSnake :: String -> String+convertCasePascalToUpperSnake = convertCase Util.CaseConventionPascal Util.CaseConventionUpperSnake+-- | Decapitalize the first letter of a string+decapitalize :: String -> String+decapitalize = mapFirstLetter Strings.toLower+-- | Escape reserved words by appending an underscore+escapeWithUnderscore :: S.Set String -> String -> String+escapeWithUnderscore reserved s = Logic.ifElse (Sets.member s reserved) (Strings.cat2 s "_") s+-- | Indent each line of a string with four spaces+indentLines :: String -> String+indentLines s =++      let indent = \l -> Strings.cat2 "    " l+      in (Strings.unlines (Lists.map indent (Strings.lines s)))+-- | Format a string as a Java-style block comment+javaStyleComment :: String -> String+javaStyleComment s = Strings.cat2 (Strings.cat2 (Strings.cat2 "/**\n" " * ") s) "\n */"+-- | A helper which maps the first letter of a string to another string+mapFirstLetter :: (String -> String) -> String -> String+mapFirstLetter mapping s =+    Logic.ifElse (Strings.null s) s (+      let list = Strings.toList s+      in (Optionals.fromOptional s (Optionals.map (\uc ->+        let firstLetter = mapping (Strings.fromList (Lists.pure (Pairs.first uc)))+        in (Strings.cat2 firstLetter (Strings.fromList (Pairs.second uc)))) (Lists.uncons list))))+-- | Replace sequences of non-alphanumeric characters with single underscores+nonAlnumToUnderscores :: String -> String+nonAlnumToUnderscores input =++      let isAlnum =+              \c -> Logic.or (Logic.and (Equality.gte c 65) (Equality.lte c 90)) (Logic.or (Logic.and (Equality.gte c 97) (Equality.lte c 122)) (Logic.and (Equality.gte c 48) (Equality.lte c 57)))+          replace =+                  \p -> \c ->+                    let s = Pairs.first p+                        b = Pairs.second p+                    in (Logic.ifElse (isAlnum c) (Lists.cons c s, False) (Logic.ifElse b (s, True) (Lists.cons 95 s, True)))+          result = Lists.foldl replace ([], False) (Strings.toList input)+      in (Strings.fromList (Lists.reverse (Pairs.first result)))+-- | Normalize a comment string for consistent output across coders+normalizeComment :: String -> String+normalizeComment s =++      let stripped = stripLeadingAndTrailingWhitespace s+      in (Logic.ifElse (Strings.null stripped) "" (+        let lastIdx = Math.sub (Strings.length stripped) 1+            appended = Strings.cat2 stripped "."+        in (Optionals.cases (Strings.maybeCharAt lastIdx stripped) appended (\lastChar -> Logic.ifElse (Equality.equal lastChar 46) stripped appended))))+-- | Sanitize a string by replacing non-alphanumeric characters and escaping reserved words+sanitizeWithUnderscores :: S.Set String -> String -> String+sanitizeWithUnderscores reserved s = escapeWithUnderscore reserved (nonAlnumToUnderscores s)+-- | Format a list of elements as a bracketed, comma-separated string+showList :: (t0 -> String) -> [t0] -> String+showList f els =+    Strings.cat [+      "[",+      (Strings.intercalate ", " (Lists.map f els)),+      "]"]+-- | Remove leading and trailing whitespace from a string+stripLeadingAndTrailingWhitespace :: String -> String+stripLeadingAndTrailingWhitespace s =+    Strings.fromList (Lists.dropWhile Chars.isSpace (Lists.reverse (Lists.dropWhile Chars.isSpace (Lists.reverse (Strings.toList s)))))+-- | Replace special characters with their alphanumeric aliases+withCharacterAliases :: String -> String+withCharacterAliases original =++      let aliases =+              Maps.fromList [+                (32, "sp"),+                (33, "excl"),+                (34, "quot"),+                (35, "num"),+                (36, "dollar"),+                (37, "percnt"),+                (38, "amp"),+                (39, "apos"),+                (40, "lpar"),+                (41, "rpar"),+                (42, "ast"),+                (43, "plus"),+                (44, "comma"),+                (45, "minus"),+                (46, "period"),+                (47, "sol"),+                (58, "colon"),+                (59, "semi"),+                (60, "lt"),+                (61, "equals"),+                (62, "gt"),+                (63, "quest"),+                (64, "commat"),+                (91, "lsqb"),+                (92, "bsol"),+                (93, "rsqb"),+                (94, "circ"),+                (95, "lowbar"),+                (96, "grave"),+                (123, "lcub"),+                (124, "verbar"),+                (125, "rcub"),+                (126, "tilde")]+          alias = \c -> Optionals.fromOptional (Lists.pure c) (Optionals.map Strings.toList (Maps.lookup c aliases))+      in (Strings.fromList (Lists.filter Chars.isAlphaNum (Lists.concat (Lists.map alias (Strings.toList original)))))+-- | A simple soft line wrap which is suitable for code comments+wrapLine :: Int -> String -> String+wrapLine maxlen input =++      let helper =+              \prev -> \rem ->+                let trunc = Lists.take maxlen rem+                    spanResult =+                            Lists.span (\c -> Logic.and (Logic.not (Equality.equal c 32)) (Logic.not (Equality.equal c 9))) (Lists.reverse trunc)+                    prefix = Lists.reverse (Pairs.second spanResult)+                    suffix = Lists.reverse (Pairs.first spanResult)+                in (Logic.ifElse (Equality.lte (Lists.length rem) maxlen) (Lists.reverse (Lists.cons rem prev)) (Logic.ifElse (Lists.null prefix) (helper (Lists.cons trunc prev) (Lists.drop maxlen rem)) (Optionals.fromOptional (helper (Lists.cons trunc prev) (Lists.drop maxlen rem)) (Optionals.map (\pfxInit -> helper (Lists.cons pfxInit prev) (Lists.concat2 suffix (Lists.drop maxlen rem))) (Lists.maybeInit prefix)))))+      in (Strings.fromList (Lists.intercalate [+        10] (helper [] (Strings.toList input))))
+ src/main/haskell/Hydra/Graph.hs view
@@ -0,0 +1,76 @@+-- Note: this is an automatically generated file. Do not edit.+-- | The extension to graphs of Hydra's core type system (hydra.core)++module Hydra.Graph where+import qualified Hydra.Core as Core+import qualified Hydra.Errors as Errors+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | A graph, or lexical environment which binds names to terms, types, primitives, and metadata+data Graph =+  Graph {+    -- | The terms bound by all term variables in scope+    graphBoundTerms :: (M.Map Core.Name Core.Term),+    -- | The type schemes of all term variables in scope+    graphBoundTypes :: (M.Map Core.Name Core.TypeScheme),+    -- | A mutable map from type variable names to their accumulated class constraints. This is populated during type inference when operations requiring Eq or Ord are encountered.+    graphClassConstraints :: (M.Map Core.Name Core.TypeVariableConstraints),+    -- | The set of term variables introduced by specifically by lambdas+    graphLambdaVariables :: (S.Set Core.Name),+    -- | Any additional metadata bound to term variables in scope+    graphMetadata :: (M.Map Core.Name Core.Term),+    -- | All primitive functions and constants by name+    graphPrimitives :: (M.Map Core.Name Primitive),+    -- | All schema types (type schemes) in scope+    graphSchemaTypes :: (M.Map Core.Name Core.TypeScheme),+    -- | The set of type variables introduced specifically by type lambdas+    graphTypeVariables :: (S.Set Core.Name)}+_Graph = Core.Name "hydra.graph.Graph"+_Graph_boundTerms = Core.Name "boundTerms"+_Graph_boundTypes = Core.Name "boundTypes"+_Graph_classConstraints = Core.Name "classConstraints"+_Graph_lambdaVariables = Core.Name "lambdaVariables"+_Graph_metadata = Core.Name "metadata"+_Graph_primitives = Core.Name "primitives"+_Graph_schemaTypes = Core.Name "schemaTypes"+_Graph_typeVariables = Core.Name "typeVariables"+-- | A library of primitive functions+data Library =+  Library {+    -- | A common prefix for all primitive function names in the library+    libraryName :: Packaging.ModuleName,+    -- | A preferred namespace prefix for function names in the library+    libraryPrefix :: String,+    -- | The primitives defined in this library+    libraryPrimitives :: [Primitive]}+_Library = Core.Name "hydra.graph.Library"+_Library_name = Core.Name "name"+_Library_prefix = Core.Name "prefix"+_Library_primitives = Core.Name "primitives"+-- | A built-in function or constant, consisting of the host-independent PrimitiveDefinition (name, signature, metadata) plus a host-specific implementation.+data Primitive =+  Primitive {+    -- | The host-independent declarative metadata for the primitive: name, description, signature, totality and purity flags, and an optional reference implementation.+    primitiveDefinition :: Packaging.PrimitiveDefinition,+    -- | A concrete, host-specific implementation of the primitive function: a mapping from a list of argument terms to a result term, or an error. Arguments are reduced and stripped of annotations by the interpreter before the implementation is invoked, so the implementation can pattern-match the argument terms directly; a higher-order primitive can return an unreduced applicative term and let the outer reducer fold it. The current carrier still threads `InferenceContext` and `Graph` for historical encode/decode and reducer-callback plumbing; no primitive's compute logic uses them, and they are slated for removal (https://github.com/CategoricalData/hydra/issues/446), sequenced with the `defaultImplementation` integration tracked in https://github.com/CategoricalData/hydra/issues/437.+    primitiveImplementation :: (Typing.InferenceContext -> Graph -> [Core.Term] -> Either Errors.Error Core.Term)}+_Primitive = Core.Name "hydra.graph.Primitive"+_Primitive_definition = Core.Name "definition"+_Primitive_implementation = Core.Name "implementation"+-- | A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms.+data TermCoder a =+  TermCoder {+    -- | The Hydra type of encoded terms+    termCoderType :: Core.Type,+    -- | An encode function from terms to native values+    termCoderEncode :: (Typing.InferenceContext -> Graph -> Core.Term -> Either Errors.Error a),+    -- | A decode function from native values to terms+    termCoderDecode :: (Typing.InferenceContext -> a -> Either Errors.Error Core.Term)}+_TermCoder = Core.Name "hydra.graph.TermCoder"+_TermCoder_type = Core.Name "type"+_TermCoder_encode = Core.Name "encode"+_TermCoder_decode = Core.Name "decode"
+ src/main/haskell/Hydra/Haskell/Lib/Chars.hs view
@@ -0,0 +1,31 @@+-- | Haskell implementations of hydra.lib.chars primitives.+-- All functions operate on Unicode code points (Int) rather than Char.++module Hydra.Haskell.Lib.Chars where++import qualified Data.Char as C+++-- | Check whether a character is alphanumeric.+isAlphaNum :: Int -> Bool+isAlphaNum = C.isAlphaNum . C.chr++-- | Check whether a character is lowercase.+isLower :: Int -> Bool+isLower = C.isLower . C.chr++-- | Check whether a character is a whitespace character.+isSpace :: Int -> Bool+isSpace = C.isSpace . C.chr++-- | Check whether a character is uppercase.+isUpper :: Int -> Bool+isUpper = C.isUpper . C.chr++-- | Convert a character to lowercase.+toLower :: Int -> Int+toLower = C.ord . C.toLower . C.chr++-- | Convert a character to uppercase.+toUpper :: Int -> Int+toUpper = C.ord . C.toUpper . C.chr
+ src/main/haskell/Hydra/Haskell/Lib/Eithers.hs view
@@ -0,0 +1,69 @@+-- | Haskell implementations of hydra.lib.eithers primitives++module Hydra.Haskell.Lib.Eithers where++import qualified Control.Monad as CM+import qualified Data.Bifunctor as BF+import qualified Data.Either as E+import qualified Data.Set as S+++-- | Map over both sides of an Either value.+bimap :: (a -> c) -> (b -> d) -> Either a b -> Either c d+bimap = BF.bimap++-- | Bind (flatMap) for Either: if Right, apply the function; if Left, return unchanged.+bind :: Either a b -> (b -> Either a c) -> Either a c+bind = (>>=)++-- | Eliminate an Either value by applying one of two functions.+either :: (a -> c) -> (b -> c) -> Either a b -> c+either = E.either++-- | Left-fold over a list with an Either-returning function, short-circuiting on Left.+foldl :: (a -> b -> Either c a) -> a -> [b] -> Either c a+foldl = CM.foldM++-- | Extract the Left value, or return a default.+fromLeft :: a -> Either a b -> a+fromLeft = E.fromLeft++-- | Extract the Right value, or return a default.+fromRight :: b -> Either a b -> b+fromRight = E.fromRight++-- | Check if an Either is a Left value.+isLeft :: Either a b -> Bool+isLeft = E.isLeft++-- | Check if an Either is a Right value.+isRight :: Either a b -> Bool+isRight = E.isRight++-- | Extract all Left values from a list of Eithers.+lefts :: [Either a b] -> [a]+lefts = E.lefts++-- | Map a function over the Right side of an Either (standard functor map).+map :: (a -> b) -> Either c a -> Either c b+map = fmap++-- | Map a function returning Either over a list, collecting results or short-circuiting on Left.+mapList :: (a -> Either c b) -> [a] -> Either c [b]+mapList = CM.mapM++-- | Map a function returning Either over an optional, or return Right Nothing if Nothing.+mapOptional :: (a -> Either c b) -> Maybe a -> Either c (Maybe b)+mapOptional = CM.mapM++-- | Map a function returning Either over a Set, collecting results or short-circuiting on Left.+mapSet :: Ord b => (a -> Either c b) -> S.Set a -> Either c (S.Set b)+mapSet f s = fmap S.fromList (CM.mapM f (S.toList s))++-- | Partition a list of Eithers into lefts and rights.+partitionEithers :: [Either a b] -> ([a], [b])+partitionEithers = E.partitionEithers++-- | Extract all Right values from a list of Eithers.+rights :: [Either a b] -> [b]+rights = E.rights
+ src/main/haskell/Hydra/Haskell/Lib/Equality.hs view
@@ -0,0 +1,47 @@+-- | Haskell implementations of hydra.lib.equality primitives.++module Hydra.Haskell.Lib.Equality where++import Hydra.Util++import Data.Int+++-- | Compare two values and return a Comparison.+compare :: Ord a => a -> a -> Comparison+compare x y+  | x < y     = ComparisonLessThan+  | x > y     = ComparisonGreaterThan+  | otherwise = ComparisonEqualTo++-- | Check if two values are equal.+equal :: Eq a => a -> a -> Bool+equal = (==)++-- | Check if first value is greater than second.+gt :: Ord a => a -> a -> Bool+gt = (>)++-- | Check if first value is greater than or equal to second.+gte :: Ord a => a -> a -> Bool+gte = (>=)++-- | Return a value unchanged.+identity :: a -> a+identity = id++-- | Check if first value is less than second.+lt :: Ord a => a -> a -> Bool+lt = (<)++-- | Check if first value is less than or equal to second.+lte :: Ord a => a -> a -> Bool+lte = (<=)++-- | Return the maximum of two values.+max :: Ord a => a -> a -> a+max = Prelude.max++-- | Return the minimum of two values.+min :: Ord a => a -> a -> a+min = Prelude.min
+ src/main/haskell/Hydra/Haskell/Lib/Lists.hs view
@@ -0,0 +1,171 @@+-- | Haskell implementations of hydra.lib.lists primitives++module Hydra.Haskell.Lib.Lists where++import Hydra.Util+import Hydra.Core+import Hydra.Graph+import qualified Hydra.Dsl.Terms as Terms++import qualified Data.List as L+++-- | Apply a list of functions to a list of values (applicative style).+apply :: [a -> b] -> [a] -> [b]+apply = (<*>)++-- | Apply a function that returns lists to each element and flatten results.+bind :: [a] -> (a -> [b]) -> [b]+bind = (>>=)++-- | Concatenate a list of lists.+concat :: [[a]] -> [a]+concat = L.concat++-- | Concatenate two lists.+concat2 :: [a] -> [a] -> [a]+concat2 l1 l2 = l1 ++ l2++-- | Prepend a value to a list.+cons :: a -> [a] -> [a]+cons = (:)++-- | Drop the first n elements from a list.+drop :: Int -> [a] -> [a]+drop = L.drop++-- | Drop elements from the beginning of a list while predicate is true.+dropWhile :: (a -> Bool) -> [a] -> [a]+dropWhile = L.dropWhile++-- | Check if an element is in a list.+elem :: Eq a => a -> [a] -> Bool+elem = L.elem++-- | Filter a list based on a predicate.+filter :: (a -> Bool) -> [a] -> [a]+filter = L.filter++-- | Find the first element matching a predicate.+find :: (a -> Bool) -> [a] -> Maybe a+find = L.find++-- | Fold a list from the left.+-- Strict left fold. Lazy foldl can pile up thunks for accumulator types+-- that are field-update records (e.g. PythonModuleMetadata in+-- Hydra.Python.Coder.extendMetaForTerm), causing pathological wallclock+-- in the Python coder's gatherMetadata pass. Use foldl' to evaluate+-- each accumulator step strictly.+foldl :: (b -> a -> b) -> b -> [a] -> b+foldl = L.foldl'++-- | Fold a list from the right.+foldr :: (a -> b -> b) -> b -> [a] -> b+foldr = L.foldr++-- | Group consecutive equal elements.+group :: Eq a => [a] -> [[a]]+group = L.group++-- | Intercalate a list of lists with a separator list between each.+intercalate :: [a] -> [[a]] -> [a]+intercalate = L.intercalate++-- | Intersperse a value between elements of a list.+intersperse :: a -> [a] -> [a]+intersperse = L.intersperse++-- | Get the length of a list.+length :: [a] -> Int+length = L.length++-- | Map a function over a list.+map :: (a -> b) -> [a] -> [b]+map = fmap++-- | Get the element at a specified index in a list, returning Nothing if out of bounds.+maybeAt :: Int -> [a] -> Maybe a+maybeAt i l+  | i < 0 || i >= L.length l = Nothing+  | otherwise = Just (l !! i)++-- | Get the first element of a list, returning Nothing if the list is empty.+maybeHead :: [a] -> Maybe a+maybeHead [] = Nothing+maybeHead (x:_) = Just x++-- | Return all elements except the last one, returning Nothing if the list is empty.+maybeInit :: [a] -> Maybe [a]+maybeInit [] = Nothing+maybeInit xs = Just (L.init xs)++-- | Get the last element of a list, returning Nothing if the list is empty.+maybeLast :: [a] -> Maybe a+maybeLast [] = Nothing+maybeLast xs = Just (L.last xs)++-- | Get all elements of a list except the first, returning Nothing if the list is empty.+maybeTail :: [a] -> Maybe [a]+maybeTail [] = Nothing+maybeTail (_:xs) = Just xs++-- | Remove duplicate elements from a list.+nub :: Eq a => [a] -> [a]+nub = L.nub++-- | Check if a list is empty.+null :: [a] -> Bool+null = L.null++-- | Partition a list into elements that satisfy a predicate and elements that do not.+partition :: (a -> Bool) -> [a] -> ([a], [a])+partition = L.partition++-- | Create a list with a single element.+pure :: a -> [a]+pure e = [e]++-- | Create a list with n copies of a value.+replicate :: Int -> a -> [a]+replicate = L.replicate++-- | Reverse a list.+reverse :: [a] -> [a]+reverse = L.reverse++-- | Create a single-element list.+singleton :: a -> [a]+singleton e = [e]++-- | Sort a list.+sort :: Ord a => [a] -> [a]+sort = L.sort++-- | Sort a list based on a key function.+sortOn :: Ord b => (a -> b) -> [a] -> [a]+sortOn = L.sortOn++-- | Split a list at the first element where predicate fails.+span :: (a -> Bool) -> [a] -> ([a], [a])+span = L.span++-- | Take the first n elements from a list.+take :: Int -> [a] -> [a]+take = L.take++-- | Transpose a list of lists.+transpose :: [[a]] -> [[a]]+transpose = L.transpose++-- | Decompose a list into its head and tail, returning Nothing if the list is empty.+uncons :: [a] -> Maybe (a, [a])+uncons [] = Nothing+uncons (x:xs) = Just (x, xs)++-- | Zip two lists into pairs.+zip :: [a] -> [b] -> [(a, b)]+zip = L.zip++-- | Zip two lists with a combining function.+zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]+zipWith = L.zipWith
+ src/main/haskell/Hydra/Haskell/Lib/Literals.hs view
@@ -0,0 +1,273 @@+-- | Haskell implementations of hydra.lib.literals primitives++module Hydra.Haskell.Lib.Literals where++import Data.Int+import Data.Scientific (Scientific, toRealFloat, fromFloatDigits)+import Text.Read (readMaybe)+import qualified Data.ByteString as B+import qualified Data.ByteString.Base64 as B64+import qualified Data.Scientific as Sci+import qualified Data.Text as T+import qualified Data.Text.Encoding as TE++-- | Convert a bigint (Integer) to a decimal (Scientific).+bigintToDecimal :: Integer -> Scientific+bigintToDecimal n = Sci.scientific n 0++-- | Convert a bigint (Integer) to an int8.+bigintToInt8 :: Integer -> Int8+bigintToInt8 = fromIntegral++-- | Convert a bigint (Integer) to an int16.+bigintToInt16 :: Integer -> Int16+bigintToInt16 = fromIntegral++-- | Convert a bigint (Integer) to an int32.+bigintToInt32 :: Integer -> Int+bigintToInt32 = fromIntegral++-- | Convert a bigint (Integer) to an int64.+bigintToInt64 :: Integer -> Int64+bigintToInt64 = fromIntegral++-- | Convert a bigint (Integer) to a uint8.+bigintToUint8 :: Integer -> Int16+bigintToUint8 = fromIntegral++-- | Convert a bigint (Integer) to a uint16.+bigintToUint16 :: Integer -> Int+bigintToUint16 = fromIntegral++-- | Convert a bigint (Integer) to a uint32.+bigintToUint32 :: Integer -> Int64+bigintToUint32 = fromIntegral++-- | Convert a bigint (Integer) to a uint64.+bigintToUint64 :: Integer -> Integer+bigintToUint64 = id++-- | Convert binary to a list of byte values (0-255).+binaryToBytes :: B.ByteString -> [Int]+binaryToBytes = fmap fromIntegral . B.unpack++-- | Convert a decimal (Scientific) to a bigint (Integer) using banker's rounding+-- (round half to even), matching Haskell's 'round' and the BigDecimal/BigInt behavior+-- in the other Hydra hosts.+decimalToBigint :: Scientific -> Integer+decimalToBigint = round++-- | Convert a decimal (Scientific) to a float32 (Float). May lose precision.+decimalToFloat32 :: Scientific -> Float+decimalToFloat32 = toRealFloat++-- | Convert a decimal (Scientific) to a float64 (Double). May lose precision.+decimalToFloat64 :: Scientific -> Double+decimalToFloat64 = toRealFloat++-- | Convert binary to string by base64 encoding.+binaryToString :: B.ByteString -> String+binaryToString = T.unpack . TE.decodeUtf8 . B64.encode++-- | Convert a float32 (Float) to a decimal (Scientific).+float32ToDecimal :: Float -> Scientific+float32ToDecimal = fromFloatDigits++-- | Convert a float32 (Float) to a float64 (Double).+-- Preserves IEEE special values (NaN, +/-Infinity); plain realToFrac+-- routes through Rational and collapses Inf to maxFinite (~3.4028e38).+float32ToFloat64 :: Float -> Double+float32ToFloat64 x+  | isNaN x      = 0/0+  | isInfinite x = if x < 0 then -1/0 else 1/0+  | otherwise    = realToFrac x++-- | Convert a float64 (Double) to a decimal (Scientific).+float64ToDecimal :: Double -> Scientific+float64ToDecimal = fromFloatDigits++-- | Convert a float64 (Double) to a float32 (Float). May lose precision.+-- IEEE special values are preserved; for finite values, realToFrac+-- (which converts via Rational) is used.+float64ToFloat32 :: Double -> Float+float64ToFloat32 x+  | isNaN x      = 0/0+  | isInfinite x = if x < 0 then -1/0 else 1/0+  | otherwise    = realToFrac x++-- | Convert an int8 to a bigint (Integer).+int8ToBigint :: Int8 -> Integer+int8ToBigint = fromIntegral++-- | Convert an int16 to a bigint (Integer).+int16ToBigint :: Int16 -> Integer+int16ToBigint = fromIntegral++-- | Convert an int32 to a bigint (Integer).+int32ToBigint :: Int -> Integer+int32ToBigint = fromIntegral++-- | Convert an int64 to a bigint (Integer).+int64ToBigint :: Int64 -> Integer+int64ToBigint = fromIntegral++-- | Parse a string to a bigint (Integer).+readBigint :: String -> Maybe Integer+readBigint s = readMaybe s :: Maybe Integer++-- | Parse a string to a boolean.+readBoolean :: String -> Maybe Bool+readBoolean s = if s == "true" then Just True+  else if s == "false" then Just False+  else Nothing++-- | Parse a string to a decimal (Scientific).+readDecimal :: String -> Maybe Scientific+readDecimal s = readMaybe s :: Maybe Scientific++-- | Parse a string to a float32 (Float).+readFloat32 :: String -> Maybe Float+readFloat32 s = readMaybe s :: Maybe Float++-- | Parse a string to a float64 (Double).+readFloat64 :: String -> Maybe Double+readFloat64 s = readMaybe s :: Maybe Double++-- | Parse a string to an int8 (-128 to 127).+readInt8 :: String -> Maybe Int8+readInt8 s = do+  n <- readMaybe s :: Maybe Integer+  if n >= -128 && n <= 127 then Just (fromIntegral n) else Nothing++-- | Parse a string to an int16 (-32768 to 32767).+readInt16 :: String -> Maybe Int16+readInt16 s = do+  n <- readMaybe s :: Maybe Integer+  if n >= -32768 && n <= 32767 then Just (fromIntegral n) else Nothing++-- | Parse a string to an int32.+readInt32 :: String -> Maybe Int+readInt32 s = readMaybe s :: Maybe Int++-- | Parse a string to an int64.+readInt64 :: String -> Maybe Int64+readInt64 s = readMaybe s :: Maybe Int64++-- | Parse a string literal.+readString :: String -> Maybe String+readString s = readMaybe s :: Maybe String++-- Note: Hydra uses wider signed types to represent unsigned values without overflow+-- Uint8 -> Int16, Uint16 -> Int, Uint32 -> Int64, Uint64 -> Integer+-- The read functions parse as unsigned and validate the range++-- | Parse a string to a uint8 (0 to 255).+readUint8 :: String -> Maybe Int16+readUint8 s = do+  n <- readMaybe s :: Maybe Integer+  if n >= 0 && n <= 255 then Just (fromIntegral n) else Nothing++-- | Parse a string to a uint16 (0 to 65535).+readUint16 :: String -> Maybe Int+readUint16 s = do+  n <- readMaybe s :: Maybe Integer+  if n >= 0 && n <= 65535 then Just (fromIntegral n) else Nothing++-- | Parse a string to a uint32 (0 to 4294967295).+readUint32 :: String -> Maybe Int64+readUint32 s = do+  n <- readMaybe s :: Maybe Integer+  if n >= 0 && n <= 4294967295 then Just (fromIntegral n) else Nothing++-- | Parse a string to a uint64 (0 to 18446744073709551615).+readUint64 :: String -> Maybe Integer+readUint64 s = do+  n <- readMaybe s :: Maybe Integer+  if n >= 0 && n <= 18446744073709551615 then Just n else Nothing++-- | Convert a bigint (Integer) to string.+showBigint :: Integer -> String+showBigint = show++-- | Convert a boolean to string.+showBoolean :: Bool -> String+showBoolean b = case b of+  True -> "true"+  False -> "false"++-- | Convert a decimal (Scientific) to string. Uses Scientific's default format+--   (regular notation for small-magnitude values; scientific notation for very+--   large or very small).+showDecimal :: Scientific -> String+showDecimal = show++-- | Convert a float32 (Float) to string.+showFloat32 :: Float -> String+showFloat32 = show++-- | Convert a float64 (Double) to string.+showFloat64 :: Double -> String+showFloat64 = show++-- | Convert an int8 to string.+showInt8 :: Int8 -> String+showInt8 = show++-- | Convert an int16 to string.+showInt16 :: Int16 -> String+showInt16 = show++-- | Convert an int32 to string.+showInt32 :: Int -> String+showInt32 = show++-- | Convert an int64 to string.+showInt64 :: Int64 -> String+showInt64 = show++-- | Convert a string to a quoted string representation.+showString :: String -> String+showString = show++-- | Convert a uint8 to string.+showUint8 :: Int16 -> String+showUint8 = show++-- | Convert a uint16 to string.+showUint16 :: Int -> String+showUint16 = show++-- | Convert a uint32 to string.+showUint32 :: Int64 -> String+showUint32 = show++-- | Convert a uint64 to string.+showUint64 :: Integer -> String+showUint64 = show++-- | Convert string to binary by base64 decoding.+-- Returns an empty ByteString if decoding fails.+stringToBinary :: String -> B.ByteString+stringToBinary s = case B64.decode (TE.encodeUtf8 $ T.pack s) of+  Left _ -> B.empty+  Right bs -> bs++-- | Parse a string as a Scientific decimal. Errors on malformed input.+stringToDecimal :: String -> Scientific+stringToDecimal = read++-- | Convert a uint8 to a bigint (Integer).+uint8ToBigint :: Int16 -> Integer+uint8ToBigint = fromIntegral++-- | Convert a uint16 to a bigint (Integer).+uint16ToBigint :: Int -> Integer+uint16ToBigint = fromIntegral++-- | Convert a uint32 to a bigint (Integer).+uint32ToBigint :: Int64 -> Integer+uint32ToBigint = fromIntegral++-- | Convert a uint64 to a bigint (Integer).+uint64ToBigint :: Integer -> Integer+uint64ToBigint = id
+ src/main/haskell/Hydra/Haskell/Lib/Logic.hs view
@@ -0,0 +1,24 @@+-- | Haskell implementations of hydra.lib.logic (logic and control flow) primitives++module Hydra.Haskell.Lib.Logic where++import Hydra.Core++import Data.Int+++-- | Compute the logical AND of two boolean values.+and :: Bool -> Bool -> Bool+and x y = x && y++-- | Compute a conditional expression.+ifElse :: Bool -> a -> a -> a+ifElse b x y = if b then x else y++-- | Compute the logical NOT of a boolean value.+not :: Bool -> Bool+not = Prelude.not++-- | Compute the logical OR of two boolean values.+or :: Bool -> Bool -> Bool+or x y = x || y
+ src/main/haskell/Hydra/Haskell/Lib/Maps.hs view
@@ -0,0 +1,86 @@+-- | Haskell implementations of hydra.lib.maps primitives++module Hydra.Haskell.Lib.Maps where++import qualified Data.Map as M+++-- | Alter a value at a key using a function.+alter :: Ord k => (Maybe v -> Maybe v) -> k -> M.Map k v -> M.Map k v+alter = M.alter++-- | Map a function over the keys and values of a map.+bimap :: (Ord k1, Ord k2) => (k1 -> k2) -> (v1 -> v2) -> M.Map k1 v1 -> M.Map k2 v2+bimap f g = M.fromList . fmap (\(k, v) -> (f k, g v)) . M.toList++-- | Remove a key from a map.+delete :: Ord k => k -> M.Map k v -> M.Map k v+delete = M.delete++-- | Get the values of a map.+elems :: M.Map k v -> [v]+elems = M.elems++-- | Create an empty map.+empty :: M.Map k v+empty = M.empty++-- | Filter a map based on values.+filter :: Ord k => (v -> Bool) -> M.Map k v -> M.Map k v+filter = M.filter++-- | Filter a map based on key-value pairs.+filterWithKey :: Ord k => (k -> v -> Bool) -> M.Map k v -> M.Map k v+filterWithKey = M.filterWithKey++-- | Lookup a value with a default.+findWithDefault :: Ord k => v -> k -> M.Map k v -> v+findWithDefault = M.findWithDefault++-- | Create a map from a list of key-value pairs.+fromList :: Ord k => [(k, v)] -> M.Map k v+fromList = M.fromList++-- | Insert a key-value pair into a map.+insert :: Ord k => k -> v -> M.Map k v -> M.Map k v+insert = M.insert++-- | Get the keys of a map.+keys :: M.Map k v -> [k]+keys = M.keys++-- | Lookup a value in a map.+lookup :: Ord k => k -> M.Map k v -> Maybe v+lookup = M.lookup++-- | Map a function over a map.+map :: (v1 -> v2) -> M.Map k v1 -> M.Map k v2+map = fmap++-- | Map a function over the keys of a map.+mapKeys :: (Ord k1, Ord k2) => (k1 -> k2) -> M.Map k1 v -> M.Map k2 v+mapKeys = M.mapKeys++-- | Check if a key is present in a map.+member :: Ord k => k -> M.Map k v -> Bool+member = M.member++-- | Check if a map is empty.+null :: M.Map k v -> Bool+null = M.null++-- | Create a map with a single key-value pair.+singleton :: k -> v -> M.Map k v+singleton = M.singleton++-- | Get the size of a map.+size :: M.Map k v -> Int+size = M.size++-- | Convert a map to a list of key-value pairs.+toList :: M.Map k v -> [(k, v)]+toList = M.toList++-- | Union two maps, with the first taking precedence.+union :: Ord k => M.Map k v -> M.Map k v -> M.Map k v+union = M.union
+ src/main/haskell/Hydra/Haskell/Lib/Math.hs view
@@ -0,0 +1,234 @@+-- | Haskell implementations of hydra.lib.math primitives++module Hydra.Haskell.Lib.Math where++import Prelude (Num, Ord, Integral, Enum, Bool, Double, Int, Integer, Float, Maybe(..), (.), ($), (+), (-), (*), (==), (||))+import qualified Prelude+++-- | Return the absolute value.+abs :: Num a => a -> a+abs = Prelude.abs++-- | Return the arc cosine of x in radians.+acos :: Double -> Double+acos = Prelude.acos++-- | Return the inverse hyperbolic cosine of x.+acosh :: Double -> Double+acosh = Prelude.acosh++-- | Add two numbers.+add :: Num a => a -> a -> a+add x y = x + y++-- | Add two Float64 numbers.+addFloat64 :: Double -> Double -> Double+addFloat64 = add++-- | Return the arc sine of x in radians.+asin :: Double -> Double+asin = Prelude.asin++-- | Return the inverse hyperbolic sine of x.+asinh :: Double -> Double+asinh = Prelude.asinh++-- | Return the arc tangent of x in radians.+atan :: Double -> Double+atan = Prelude.atan++-- | Return the arc tangent of y/x in radians, using signs to determine quadrant.+atan2 :: Double -> Double -> Double+atan2 = Prelude.atan2++-- | Return the inverse hyperbolic tangent of x.+atanh :: Double -> Double+atanh = Prelude.atanh++-- | Return the ceiling of x as a float.+--+-- DIVERGENCE FROM HASKELL: Haskell's Prelude.ceiling returns an Integer, which+-- cannot represent NaN or Inf; GHC's behavior on those inputs is undefined and+-- produces nonsensical gigantic integers. Hydra returns a Float64 instead so+-- that NaN and ±Inf propagate naturally per IEEE 754, matching the conventions+-- of C (ceil), Java (Math.ceil), Go (math.Ceil), Rust (f64::ceil), and JavaScript+-- (Math.ceil). Users who need an Integer value must convert explicitly.+ceiling :: Double -> Double+ceiling x+  | Prelude.isNaN x Prelude.|| Prelude.isInfinite x = x+  | Prelude.otherwise = Prelude.fromIntegral (Prelude.ceiling x :: Integer)++-- | Return the cosine of x radians.+cos :: Double -> Double+cos = Prelude.cos++-- | Return the hyperbolic cosine of x.+cosh :: Double -> Double+cosh = Prelude.cosh++-- | Euler's number (e ≈ 2.71828).+e :: Double+e = Prelude.exp 1.0++-- | Check if an integer is even.+even :: Integral a => a -> Bool+even = Prelude.even++-- | Return e raised to the power x.+exp :: Double -> Double+exp = Prelude.exp++-- | Return the floor of x as a float.+--+-- DIVERGENCE FROM HASKELL: see the note on ceiling. Returns Float64 rather than+-- Integer so that NaN and ±Inf propagate naturally per IEEE 754.+floor :: Double -> Double+floor x+  | Prelude.isNaN x Prelude.|| Prelude.isInfinite x = x+  | Prelude.otherwise = Prelude.fromIntegral (Prelude.floor x :: Integer)++-- | Return the natural logarithm of x.+log :: Double -> Double+log = Prelude.log++-- | Return the logarithm of x to the given base.+logBase :: Double -> Double -> Double+logBase = Prelude.logBase++-- | Return the maximum of two values.+max :: Ord a => a -> a -> a+max = Prelude.max++-- | Divide two integers using integer division, returning Nothing on division by zero.+maybeDiv :: Int -> Int -> Maybe Int+maybeDiv _ 0 = Nothing+maybeDiv x y = Just (Prelude.div x y)++-- | Return the minimum of two values.+min :: Ord a => a -> a -> a+min = Prelude.min++-- | Mathematical modulo, returning Nothing on division by zero.+maybeMod :: Int -> Int -> Maybe Int+maybeMod _ 0 = Nothing+maybeMod x y = Just (Prelude.mod x y)++-- | Multiply two numbers.+mul :: Num a => a -> a -> a+mul x y = x * y++-- | Multiply two Float64 numbers.+mulFloat64 :: Double -> Double -> Double+mulFloat64 = mul++-- | Negate a number.+negate :: Num a => a -> a+negate = Prelude.negate++-- | Negate a Float64 number.+negateFloat64 :: Double -> Double+negateFloat64 = Prelude.negate++-- | Check if an integer is odd.+odd :: Integral a => a -> Bool+odd = Prelude.odd++-- | Pi (π ≈ 3.14159).+pi :: Double+pi = Prelude.pi++-- | Return x raised to the power y.+pow :: Double -> Double -> Double+pow = (Prelude.**)++-- | Return the predecessor (x - 1), returning Nothing on int32 minBound.+maybePred :: Int -> Maybe Int+maybePred x+  | x == (-2147483648) = Nothing+  | Prelude.otherwise = Just (x - 1)++-- | Generate a range of values from start to end (inclusive).+range :: Enum a => a -> a -> [a]+range start end = [start .. end]++-- | Integer remainder, returning Nothing on division by zero.+maybeRem :: Int -> Int -> Maybe Int+maybeRem _ 0 = Nothing+maybeRem x y = Just (Prelude.rem x y)++-- | Return x rounded to the nearest integer, as a float.+--+-- DIVERGENCE FROM HASKELL: see the note on ceiling. Returns Float64 rather than+-- Integer so that NaN and ±Inf propagate naturally per IEEE 754.+round :: Double -> Double+round x+  | Prelude.isNaN x Prelude.|| Prelude.isInfinite x = x+  | Prelude.otherwise = Prelude.fromIntegral (Prelude.round x :: Integer)++-- | Round a float32 to n significant digits.+-- Returns NaN/Inf inputs unchanged (no rounding is possible).+roundFloat32 :: Int -> Float -> Float+roundFloat32 n x+  | Prelude.isNaN x Prelude.|| Prelude.isInfinite x = x+  | x Prelude.== 0 = 0+  | Prelude.otherwise =+      let factor = 10 Prelude.^^ (n - 1 - Prelude.floor (Prelude.logBase 10 (Prelude.abs x)))+      in Prelude.fromIntegral (Prelude.round (x * factor) :: Integer) Prelude./ factor++-- | Round a float64 to n significant digits.+-- Returns NaN/Inf inputs unchanged (no rounding is possible).+roundFloat64 :: Int -> Double -> Double+roundFloat64 n x+  | Prelude.isNaN x Prelude.|| Prelude.isInfinite x = x+  | x Prelude.== 0 = 0+  | Prelude.otherwise =+      let factor = 10 Prelude.^^ (n - 1 - Prelude.floor (Prelude.logBase 10 (Prelude.abs x)))+      in Prelude.fromIntegral (Prelude.round (x * factor) :: Integer) Prelude./ factor++-- | Return the sign of a number (-1, 0, or 1).+signum :: Num a => a -> a+signum = Prelude.signum++-- | Return the sine of x radians.+sin :: Double -> Double+sin = Prelude.sin++-- | Return the hyperbolic sine of x.+sinh :: Double -> Double+sinh = Prelude.sinh++-- | Return the square root of x.+sqrt :: Double -> Double+sqrt = Prelude.sqrt++-- | Subtract two numbers.+sub :: Num a => a -> a -> a+sub x y = x - y++-- | Subtract two Float64 numbers.+subFloat64 :: Double -> Double -> Double+subFloat64 = sub++-- | Return the successor (x + 1), returning Nothing on int32 maxBound.+maybeSucc :: Int -> Maybe Int+maybeSucc x+  | x == 2147483647 = Nothing+  | Prelude.otherwise = Just (x + 1)++-- | Return the tangent of x radians.+tan :: Double -> Double+tan = Prelude.tan++-- | Return the hyperbolic tangent of x.+tanh :: Double -> Double+tanh = Prelude.tanh++-- | Return x truncated (towards zero), as a float.+--+-- DIVERGENCE FROM HASKELL: see the note on ceiling. Returns Float64 rather than+-- Integer so that NaN and ±Inf propagate naturally per IEEE 754.+truncate :: Double -> Double+truncate x+  | Prelude.isNaN x Prelude.|| Prelude.isInfinite x = x+  | Prelude.otherwise = Prelude.fromIntegral (Prelude.truncate x :: Integer)
+ src/main/haskell/Hydra/Haskell/Lib/Optionals.hs view
@@ -0,0 +1,54 @@+-- | Haskell implementations of hydra.lib.optionals primitives++module Hydra.Haskell.Lib.Optionals where++import qualified Data.Maybe as Y+++-- | Apply a function to an argument (applicative).+apply :: Y.Maybe (a -> b) -> Y.Maybe a -> Y.Maybe b+apply = (<*>)++-- | Chain operations on optional values, handling absent cases automatically.+bind :: Y.Maybe a -> (a -> Y.Maybe b) -> Y.Maybe b+bind = (>>=)++-- | Handle an optional value with the absent-case value as the first argument.+cases :: Y.Maybe a -> b -> (a -> b) -> b+cases m n j = Y.maybe n j m++-- | Filter out absent values from a list.+cat :: [Y.Maybe a] -> [a]+cat = Y.catMaybes++-- | Compose two optional-returning functions (Kleisli composition).+compose :: (a -> Y.Maybe b) -> (b -> Y.Maybe c) -> (a -> Y.Maybe c)+compose f g = \x -> f x >>= g++-- | Get a value from an optional value, or return a default value.+fromOptional :: a -> Y.Maybe a -> a+fromOptional = Y.fromMaybe++-- | Check if a value is present.+isGiven :: Y.Maybe a -> Bool+isGiven = Y.isJust++-- | Check if a value is absent.+isNone :: Y.Maybe a -> Bool+isNone = Y.isNothing++-- | Map a function over an optional value.+map :: (a -> b) -> Y.Maybe a -> Y.Maybe b+map = fmap++-- | Map a function over a list and collect present results.+mapOptional :: (a -> Y.Maybe b) -> [a] -> [b]+mapOptional = Y.mapMaybe++-- | Lift a value into the optional type.+pure :: a -> Y.Maybe a+pure = Just++-- | Convert an optional value to a list: a present value becomes [x], an absent value becomes [].+toList :: Y.Maybe a -> [a]+toList = Y.maybeToList
+ src/main/haskell/Hydra/Haskell/Lib/Pairs.hs view
@@ -0,0 +1,18 @@+-- | Haskell implementations of hydra.lib.pairs primitives++module Hydra.Haskell.Lib.Pairs where++import qualified Data.Bifunctor as BF+++-- | Map over both elements of a pair.+bimap :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)+bimap = BF.bimap++-- | Get the first element of a pair.+first :: (a, b) -> a+first (x, _) = x++-- | Get the second element of a pair.+second :: (a, b) -> b+second (_, y) = y
+ src/main/haskell/Hydra/Haskell/Lib/Regex.hs view
@@ -0,0 +1,48 @@+-- | Haskell implementations of hydra.lib.regex primitives++module Hydra.Haskell.Lib.Regex where++import qualified Text.Regex.TDFA as R+++-- | Find the first substring matching a regex pattern.+find :: String -> String -> Maybe String+find pattern input = case (input R.=~ pattern :: (String, String, String)) of+  (_, match, _)+    | null match -> Nothing+    | otherwise  -> Just match++-- | Find all non-overlapping substrings matching a regex pattern.+findAll :: String -> String -> [String]+findAll pattern input = R.getAllTextMatches (input R.=~ pattern :: R.AllTextMatches [] String)++-- | Check whether an entire string matches a regex pattern.+matches :: String -> String -> Bool+matches pattern input = input R.=~ ("^(" ++ pattern ++ ")$" :: String) :: Bool++-- | Replace the first occurrence of a regex pattern with a replacement string.+replace :: String -> String -> String -> String+replace pattern replacement input = case (input R.=~ pattern :: (String, String, String)) of+  (before, match, after)+    | null match -> input+    | otherwise  -> before ++ replacement ++ after++-- | Replace all non-overlapping occurrences of a regex pattern with a replacement string.+replaceAll :: String -> String -> String -> String+replaceAll pattern replacement input = go input+  where+    go "" = ""+    go s = case (s R.=~ pattern :: (String, String, String)) of+      (before, match, after)+        | null match -> s+        | otherwise  -> before ++ replacement ++ go after++-- | Split a string by a regex pattern.+split :: String -> String -> [String]+split pattern input = go input+  where+    go "" = [""]+    go s = case (s R.=~ pattern :: (String, String, String)) of+      (before, match, after)+        | null match -> [s]+        | otherwise  -> before : go after
+ src/main/haskell/Hydra/Haskell/Lib/Sets.hs view
@@ -0,0 +1,64 @@+-- | Haskell implementations of hydra.lib.sets primitives++module Hydra.Haskell.Lib.Sets where++import qualified Data.Set as S+++-- | Delete an element from a set.+delete :: Ord x => x -> S.Set x -> S.Set x+delete = S.delete++-- | Compute the difference of two sets.+difference :: Ord x => S.Set x -> S.Set x -> S.Set x+difference = S.difference++-- | Create an empty set.+empty :: S.Set x+empty = S.empty++-- | Create a set from a list.+fromList :: Ord x => [x] -> S.Set x+fromList = S.fromList++-- | Insert an element into a set.+insert :: Ord x => x -> S.Set x -> S.Set x+insert = S.insert++-- | Compute the intersection of two sets.+intersection :: Ord x => S.Set x -> S.Set x -> S.Set x+intersection = S.intersection++-- | Map a function over a set.+-- Note: the presence of a 'map' function does not imply that sets are a functor in Hydra+map :: Ord y => (x -> y) -> S.Set x -> S.Set y+map f = S.fromList . fmap f . S.toList++-- | Check if an element is in a set.+member :: Ord x => x -> S.Set x -> Bool+member = S.member++-- | Check if a set is empty.+null :: S.Set x -> Bool+null = S.null++-- | Create a singleton set.+-- Consider renaming this to Sets.pure, or creating an alias+singleton :: x -> S.Set x+singleton = S.singleton++-- | Get the size of a set.+size :: S.Set x -> Int+size = S.size++-- | Convert a set to a list.+toList :: Ord x => S.Set x -> [x]+toList = S.toList++-- | Compute the union of two sets.+union :: Ord x => S.Set x -> S.Set x -> S.Set x+union = S.union++-- | Compute the union of multiple sets.+unions :: Ord x => [S.Set x] -> S.Set x+unions = S.unions
+ src/main/haskell/Hydra/Haskell/Lib/Strings.hs view
@@ -0,0 +1,62 @@+-- | Haskell implementations of hydra.lib.strings primitives++module Hydra.Haskell.Lib.Strings where++import qualified Data.Char as C+import qualified Data.List as L+import qualified Data.List.Split as LS+++-- | Concatenate a list of strings into a single string.+cat :: [String] -> String+cat = L.concat++-- | Concatenate two strings.+cat2 :: String -> String -> String+cat2 s1 s2 = s1 ++ s2++-- | Convert a list of Unicode code points to a string.+fromList :: [Int] -> String+fromList = fmap C.chr++-- | Join a list of strings with a separator between each element.+intercalate :: String -> [String] -> String+intercalate = L.intercalate++-- | Return the length of a string.+length :: String -> Int+length = L.length++-- | Get the Unicode code point of the character at a specific index, returning Nothing if out of bounds.+maybeCharAt :: Int -> String -> Maybe Int+maybeCharAt i s+  | i < 0 || i >= L.length s = Nothing+  | otherwise = Just (C.ord (s !! i))++-- | Split a string into lines.+lines :: String -> [String]+lines = L.lines++-- | Check whether a string is empty.+null :: String -> Bool+null = L.null++-- | Split a string on a delimiter string.+splitOn :: String -> String -> [String]+splitOn = LS.splitOn++-- | Convert a string to a list of Unicode code points.+toList :: String -> [Int]+toList = fmap C.ord++-- | Convert a string to lowercase.+toLower :: String -> String+toLower = fmap C.toLower++-- | Convert a string to uppercase.+toUpper :: String -> String+toUpper = fmap C.toUpper++-- | Join a list of strings with newlines, appending a trailing newline.+unlines :: [String] -> String+unlines = L.unlines
+ src/main/haskell/Hydra/Hoisting.hs view
@@ -0,0 +1,490 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Functions for deep term rewriting operations involving hoisting subterms or bindings into enclosing let terms.++module Hydra.Hoisting where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Environment as Environment+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Resolution as Resolution+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Strip as Strip+import qualified Hydra.Substitution as Substitution+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | Augment bindings with new free variables introduced by substitution, wrapping with lambdas after any type lambdas.+augmentBindingsWithNewFreeVars :: Graph.Graph -> S.Set Core.Name -> [Core.Binding] -> ([Core.Binding], Typing.TermSubst)+augmentBindingsWithNewFreeVars cx boundVars bindings =++      let types = Maps.map Scoping.typeSchemeToFType (Graph.graphBoundTypes cx)+          wrapAfterTypeLambdas =+                  \vars -> \term -> case term of+                    Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda {+                      Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+                      Core.typeLambdaBody = (wrapAfterTypeLambdas vars (Core.typeLambdaBody v0))})+                    _ -> Lists.foldl (\t -> \p -> Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Pairs.first p),+                      Core.lambdaDomain = (Pairs.second p),+                      Core.lambdaBody = t})) term (Lists.reverse vars)+          augment =+                  \b ->+                    let freeVars = Sets.toList (Sets.intersection boundVars (Variables.freeVariablesInTerm (Core.bindingTerm b)))+                        varTypePairs = Lists.map (\v -> (v, (Maps.lookup v types))) freeVars+                        varTypes = Optionals.cat (Lists.map Pairs.second varTypePairs)+                    in (Logic.ifElse (Logic.or (Lists.null freeVars) (Logic.not (Equality.equal (Lists.length varTypes) (Lists.length varTypePairs)))) (b, Nothing) (+                      Core.Binding {+                        Core.bindingName = (Core.bindingName b),+                        Core.bindingTerm = (wrapAfterTypeLambdas varTypePairs (Core.bindingTerm b)),+                        Core.bindingTypeScheme = (Optionals.map (\ts -> Core.TypeScheme {+                          Core.typeSchemeVariables = (Core.typeSchemeVariables ts),+                          Core.typeSchemeBody = (Lists.foldl (\acc -> \t -> Core.TypeFunction (Core.FunctionType {+                            Core.functionTypeDomain = t,+                            Core.functionTypeCodomain = acc})) (Core.typeSchemeBody ts) (Lists.reverse varTypes)),+                          Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)}) (Core.bindingTypeScheme b))},+                      (Just (+                        Core.bindingName b,+                        (Lists.foldl (\t -> \v -> Core.TermApplication (Core.Application {+                          Core.applicationFunction = t,+                          Core.applicationArgument = (Core.TermVariable v)})) (Core.TermVariable (Core.bindingName b)) freeVars)))))+          results = Lists.map augment bindings+      in (Lists.map Pairs.first results, (Typing.TermSubst (Maps.fromList (Optionals.cat (Lists.map Pairs.second results)))))+-- | Check if a binding has a polymorphic type (non-empty list of type scheme variables)+bindingIsPolymorphic :: Core.Binding -> Bool+bindingIsPolymorphic binding =+    Optionals.cases (Core.bindingTypeScheme binding) False (\ts -> Logic.not (Lists.null (Core.typeSchemeVariables ts)))+-- | Check if a binding's type uses any type variables from the given Graph. Returns True if the free type variables in the binding's type intersect with the type variables in scope (graphTypeVariables).+bindingUsesContextTypeVars :: Graph.Graph -> Core.Binding -> Bool+bindingUsesContextTypeVars cx binding =+    Optionals.cases (Core.bindingTypeScheme binding) False (\ts ->+      let freeInType = Variables.freeVariablesInType (Core.typeSchemeBody ts)+          contextTypeVars = Graph.graphTypeVariables cx+      in (Logic.not (Sets.null (Sets.intersection freeInType contextTypeVars))))+-- | Count the number of occurrences of a variable name in a term. Assumes no variable shadowing.+countVarOccurrences :: Core.Name -> Core.Term -> Int+countVarOccurrences name term =++      let childCount = Lists.foldl (\acc -> \t -> Math.add acc (countVarOccurrences name t)) 0 (Rewriting.subterms term)+      in case term of+        Core.TermVariable v0 -> Logic.ifElse (Equality.equal v0 name) (Math.add 1 childCount) childCount+        _ -> childCount+-- | Transform a let-term by pulling ALL let bindings to the top level. This is useful for targets like Java that don't support nested let expressions at all. If a hoisted binding captures lambda-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. Note: Assumes no variable shadowing; use hydra.rewriting.unshadowVariables first.+hoistAllLetBindings :: Core.Let -> Core.Let+hoistAllLetBindings let0 =++      let emptyCx =+              Graph.Graph {+                Graph.graphBoundTerms = Maps.empty,+                Graph.graphBoundTypes = Maps.empty,+                Graph.graphClassConstraints = Maps.empty,+                Graph.graphLambdaVariables = Sets.empty,+                Graph.graphMetadata = Maps.empty,+                Graph.graphPrimitives = Maps.empty,+                Graph.graphSchemaTypes = Maps.empty,+                Graph.graphTypeVariables = Sets.empty}+      in (hoistLetBindingsWithPredicate (\_ -> True) shouldHoistAll emptyCx let0)+-- | Hoist case statements into local let bindings. This is useful for targets such as Python which only support case statements (match) at the top level. Case statements are hoisted only when they appear at non-top-level positions. Top level = root, or reachable through annotations, let body/binding, lambda bodies, or ONE application LHS. Once through an application LHS, lambda bodies no longer count as pass-through.+hoistCaseStatements :: Graph.Graph -> Core.Term -> Core.Term+hoistCaseStatements = hoistSubterms shouldHoistCaseStatement+-- | Hoist case statements into local let bindings for a list of bindings. This version operates prior to inference and uses an empty type context. It hoists case statements and their applied arguments into let bindings.+hoistCaseStatementsInGraph :: [Core.Binding] -> [Core.Binding]+hoistCaseStatementsInGraph bindings =++      let emptyTx =+              Graph.Graph {+                Graph.graphBoundTerms = Maps.empty,+                Graph.graphBoundTypes = Maps.empty,+                Graph.graphClassConstraints = Maps.empty,+                Graph.graphLambdaVariables = Sets.empty,+                Graph.graphMetadata = Maps.empty,+                Graph.graphPrimitives = Maps.empty,+                Graph.graphSchemaTypes = Maps.empty,+                Graph.graphTypeVariables = Sets.empty}+          term0 =+                  Core.TermLet (Core.Let {+                    Core.letBindings = bindings,+                    Core.letBody = Core.TermUnit})+          term1 = hoistCaseStatements emptyTx term0+      in (Environment.termAsBindings term1)+-- | Transform a let-term by pulling polymorphic let bindings to the top level, using Graph. A binding is hoisted if: (1) It is polymorphic (has non-empty typeSchemeVariables), OR (2) Its type uses type variables from the Graph (i.e., from enclosing type lambdas). Bindings which are already at the top level are not hoisted. If a hoisted binding captures lambda-bound or let-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. If a hoisted binding uses type variables from the context, those type variables are added to the binding's type scheme. Note: we assume that there is no variable shadowing; use hydra.rewriting.unshadowVariables first.+hoistLetBindingsWithContext :: (Core.Binding -> Bool) -> Graph.Graph -> Core.Let -> Core.Let+hoistLetBindingsWithContext isParentBinding cx let0 =+    hoistLetBindingsWithPredicate isParentBinding shouldHoistPolymorphic cx let0+-- | Transform a let-term by pulling let bindings to the top level. The isParentBinding predicate applies to top-level bindings and determines whether their subterm bindings are eligible for hoisting. The shouldHoistBinding predicate takes the Graph and a subterm binding, and returns True if the binding should be hoisted. This is useful for targets like Java that cannot have polymorphic definitions in arbitrary positions. The Graph provides information about type variables and lambda variables in scope. If a hoisted binding captures let-bound or lambda-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. If a hoisted binding captures type variables from an enclosing type lambda scope, those type variables are added to the binding's type scheme, and references are replaced with type applications. Note: we assume that there is no variable shadowing; use hydra.rewriting.unshadowVariables first.+hoistLetBindingsWithPredicate :: (Core.Binding -> Bool) -> (Graph.Graph -> Core.Binding -> Bool) -> Graph.Graph -> Core.Let -> Core.Let+hoistLetBindingsWithPredicate isParentBinding shouldHoistBinding cx0 let0 =++      let hoistOne =+              \prefix -> \cx -> \pair -> \bindingWithCapturedVars ->+                let bindingAndReplacementPairs = Pairs.first pair+                    alreadyUsedNames = Pairs.second pair+                    b = Pairs.first bindingWithCapturedVars+                    capturedTermVars = Pairs.second bindingWithCapturedVars+                    types = Maps.map Scoping.typeSchemeToFType (Graph.graphBoundTypes cx)+                    capturedTermVarTypePairs = Lists.map (\v -> (v, (Maps.lookup v types))) capturedTermVars+                    capturedTermVarTypes =+                            Lists.map (\typ -> Strip.deannotateTypeParameters typ) (Optionals.cat (Lists.map Pairs.second capturedTermVarTypePairs))+                    freeInBindingType =+                            Optionals.cases (Core.bindingTypeScheme b) Sets.empty (\ts -> Variables.freeVariablesInType (Core.typeSchemeBody ts))+                    freeInCapturedVarTypes = Sets.unions (Lists.map (\t -> Variables.freeVariablesInType t) capturedTermVarTypes)+                    capturedTypeVars =+                            Sets.toList (Sets.intersection (Graph.graphTypeVariables cx) (Sets.union freeInBindingType freeInCapturedVarTypes))+                    globalBindingName =+                            Lexical.chooseUniqueName alreadyUsedNames (Core.Name (Strings.cat2 prefix (Core.unName (Core.bindingName b))))+                    newUsedNames = Sets.insert globalBindingName alreadyUsedNames+                    newTypeScheme =+                            Logic.ifElse (Equality.equal (Lists.length capturedTermVarTypes) (Lists.length capturedTermVarTypePairs)) (Optionals.map (\ts -> Core.TypeScheme {+                              Core.typeSchemeVariables = (Lists.nub (Lists.concat2 capturedTypeVars (Core.typeSchemeVariables ts))),+                              Core.typeSchemeBody = (Lists.foldl (\t -> \a -> Core.TypeFunction (Core.FunctionType {+                                Core.functionTypeDomain = a,+                                Core.functionTypeCodomain = t})) (Core.typeSchemeBody ts) (Lists.reverse capturedTermVarTypes)),+                              Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)}) (Core.bindingTypeScheme b)) Nothing+                    strippedTerm = Strip.stripTypeLambdas (Core.bindingTerm b)+                    termWithLambdas =+                            Lists.foldl (\t -> \p -> Core.TermLambda (Core.Lambda {+                              Core.lambdaParameter = (Pairs.first p),+                              Core.lambdaDomain = (Optionals.map (\dom -> Strip.deannotateTypeParameters dom) (Pairs.second p)),+                              Core.lambdaBody = t})) strippedTerm (Lists.reverse capturedTermVarTypePairs)+                    termWithTypeLambdas =+                            Lists.foldl (\t -> \v -> Core.TermTypeLambda (Core.TypeLambda {+                              Core.typeLambdaParameter = v,+                              Core.typeLambdaBody = t})) termWithLambdas (Lists.reverse (Optionals.cases newTypeScheme [] Core.typeSchemeVariables))+                    withTypeApps =+                            Lists.foldl (\t -> \v -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                              Core.typeApplicationTermBody = t,+                              Core.typeApplicationTermType = (Core.TypeVariable v)})) (Core.TermVariable globalBindingName) capturedTypeVars+                    replacement =+                            Lists.foldl (\t -> \v -> Core.TermApplication (Core.Application {+                              Core.applicationFunction = t,+                              Core.applicationArgument = (Core.TermVariable v)})) withTypeApps capturedTermVars+                    newBindingAndReplacement =+                            (+                              Core.Binding {+                                Core.bindingName = globalBindingName,+                                Core.bindingTerm = termWithTypeLambdas,+                                Core.bindingTypeScheme = newTypeScheme},+                              replacement)+                    newPairs = Lists.cons newBindingAndReplacement bindingAndReplacementPairs+                in (newPairs, newUsedNames)+          rewrite =+                  \prefix -> \recurse -> \cx -> \bindingsAndNames -> \term ->+                    let previouslyFinishedBindings = Pairs.first bindingsAndNames+                        emptyBindingsAndNames = ([], (Pairs.second bindingsAndNames))+                        result = recurse emptyBindingsAndNames term+                        newBindingsAndNames = Pairs.first result+                        bindingsSoFar = Pairs.first newBindingsAndNames+                        alreadyUsedNames = Pairs.second newBindingsAndNames+                        newTerm = Pairs.second result+                    in case newTerm of+                      Core.TermLet v0 ->+                        let body = Core.letBody v0+                            partitionPair = Lists.partition (shouldHoistBinding cx) (Core.letBindings v0)+                            hoistUs = Pairs.first partitionPair+                            keepUs = Pairs.second partitionPair+                            hoistedBindingNames = Lists.map Core.bindingName hoistUs+                            polyLetVariables =+                                    Sets.fromList (Lists.filter (\v -> Optionals.cases (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v (Graph.graphBoundTypes cx))) False Resolution.fTypeIsPolymorphic) (Sets.toList (Sets.difference (Sets.fromList (Maps.keys (Graph.graphBoundTerms cx))) (Graph.graphLambdaVariables cx))))+                            boundTermVariables =+                                    Sets.union (Graph.graphLambdaVariables cx) (Sets.difference (Sets.fromList (Maps.keys (Graph.graphBoundTerms cx))) (Graph.graphLambdaVariables cx))+                            freeVariablesInEachBinding =+                                    Lists.map (\b -> Sets.toList (Sets.intersection boundTermVariables (Variables.freeVariablesInTerm (Core.bindingTerm b)))) hoistUs+                            bindingDependencies =+                                    Lists.map (\vars -> Lists.partition (\v -> Sets.member v (Sets.fromList hoistedBindingNames)) vars) freeVariablesInEachBinding+                            bindingEdges = Lists.zip hoistedBindingNames (Lists.map Pairs.first bindingDependencies)+                            bindingImmediateCapturedVars = Lists.zip hoistedBindingNames (Lists.map Pairs.second bindingDependencies)+                            capturedVarsMap = Maps.fromList (Sorting.propagateTags bindingEdges bindingImmediateCapturedVars)+                            bindingsWithCapturedVars =+                                    Lists.map (\b -> (+                                      b,+                                      (Optionals.cases (Maps.lookup (Core.bindingName b) capturedVarsMap) [] (\vars -> Sets.toList (Sets.difference vars polyLetVariables))))) hoistUs+                            hoistPairsAndNames = Lists.foldl (hoistOne prefix cx) ([], alreadyUsedNames) bindingsWithCapturedVars+                            hoistPairs = Lists.reverse (Pairs.first hoistPairsAndNames)+                            hoistedBindings = Lists.map Pairs.first hoistPairs+                            replacements = Lists.map Pairs.second hoistPairs+                            finalUsedNames = Pairs.second hoistPairsAndNames+                            hoistNameReplacementPairs = Lists.zip (Lists.map Core.bindingName hoistUs) replacements+                            hoistBindingMap = Maps.fromList (Lists.map (\b -> (Core.bindingName b, b)) hoistUs)+                            isCacheable =+                                    \name ->+                                      let multiRef = Equality.gte (countVarOccurrences name body) 2+                                          isPoly = Optionals.cases (Maps.lookup name hoistBindingMap) False (\b -> bindingIsPolymorphic b)+                                      in (Logic.and multiRef (Logic.not isPoly))+                            singleRefPairs = Lists.filter (\p -> Logic.not (isCacheable (Pairs.first p))) hoistNameReplacementPairs+                            multiRefPairs = Lists.filter (\p -> isCacheable (Pairs.first p)) hoistNameReplacementPairs+                            fullSubst = Typing.TermSubst (Maps.fromList hoistNameReplacementPairs)+                            bodyOnlySubst = Typing.TermSubst (Maps.fromList singleRefPairs)+                            bodySubst = Substitution.substituteInTerm bodyOnlySubst body+                            cacheBindings =+                                    Lists.map (\p ->+                                      let origType = Optionals.cases (Maps.lookup (Pairs.first p) hoistBindingMap) Nothing (\b -> Core.bindingTypeScheme b)+                                      in Core.Binding {+                                        Core.bindingName = (Pairs.first p),+                                        Core.bindingTerm = (Pairs.second p),+                                        Core.bindingTypeScheme = origType}) multiRefPairs+                            bodyWithCache =+                                    Logic.ifElse (Lists.null cacheBindings) bodySubst (Core.TermLet (Core.Let {+                                      Core.letBindings = cacheBindings,+                                      Core.letBody = bodySubst}))+                            keepUsSubst = Lists.map (Substitution.substituteInBinding fullSubst) keepUs+                            hoistedBindingsSubst = Lists.map (Substitution.substituteInBinding fullSubst) hoistedBindings+                            bindingsSoFarSubst = Lists.map (Substitution.substituteInBinding fullSubst) bindingsSoFar+                            augmentResult = augmentBindingsWithNewFreeVars cx (Sets.difference boundTermVariables polyLetVariables) bindingsSoFarSubst+                            bindingsSoFarAugmented = Pairs.first augmentResult+                            augmentSubst = Pairs.second augmentResult+                            hoistedBindingsFinal = Lists.map (Substitution.substituteInBinding augmentSubst) hoistedBindingsSubst+                            bindingsSoFarFinal = Lists.map (Substitution.substituteInBinding augmentSubst) bindingsSoFarAugmented+                            bodyFinal = Substitution.substituteInTerm augmentSubst bodyWithCache+                            keepUsFinal = Lists.map (Substitution.substituteInBinding augmentSubst) keepUsSubst+                            finalTerm =+                                    Logic.ifElse (Lists.null keepUsFinal) bodyFinal (Core.TermLet (Core.Let {+                                      Core.letBindings = keepUsFinal,+                                      Core.letBody = bodyFinal}))+                        in (+                          (+                            Lists.concat [+                              previouslyFinishedBindings,+                              hoistedBindingsFinal,+                              bindingsSoFarFinal],+                            finalUsedNames),+                          finalTerm)+                      _ -> ((Lists.concat2 previouslyFinishedBindings bindingsSoFar, alreadyUsedNames), newTerm)+          cx1 = Scoping.extendGraphForLet (\c -> \b -> Nothing) cx0 let0+          forActiveBinding =+                  \b ->+                    let prefix = Strings.cat2 (Core.unName (Core.bindingName b)) "_"+                        init = ([], (Sets.singleton (Core.bindingName b)))+                        resultPair = Rewriting.rewriteAndFoldTermWithGraph (rewrite prefix) cx1 init (Core.bindingTerm b)+                        resultBindings = Pairs.first (Pairs.first resultPair)+                        resultTerm = Pairs.second resultPair+                    in (Lists.cons (Core.Binding {+                      Core.bindingName = (Core.bindingName b),+                      Core.bindingTerm = resultTerm,+                      Core.bindingTypeScheme = (Core.bindingTypeScheme b)}) resultBindings)+          forBinding = \b -> Logic.ifElse (isParentBinding b) (forActiveBinding b) [+                b]+      in Core.Let {+        Core.letBindings = (Lists.concat (Lists.map forBinding (Core.letBindings let0))),+        Core.letBody = (Core.letBody let0)}+-- | Transform a let-term by pulling all polymorphic let bindings to the top level. This is useful to ensure that polymorphic bindings are not nested within other terms, which is unsupported by certain targets such as Java. Polymorphic bindings are those with a non-empty list of type scheme variables. If a hoisted binding captures lambda-bound variables from an enclosing scope, the binding is wrapped in lambdas for those variables, and references are replaced with applications. Note: Assumes no variable shadowing; use hydra.rewriting.unshadowVariables first.+hoistPolymorphicLetBindings :: (Core.Binding -> Bool) -> Core.Let -> Core.Let+hoistPolymorphicLetBindings isParentBinding let0 =++      let emptyCx =+              Graph.Graph {+                Graph.graphBoundTerms = Maps.empty,+                Graph.graphBoundTypes = Maps.empty,+                Graph.graphClassConstraints = Maps.empty,+                Graph.graphLambdaVariables = Sets.empty,+                Graph.graphMetadata = Maps.empty,+                Graph.graphPrimitives = Maps.empty,+                Graph.graphSchemaTypes = Maps.empty,+                Graph.graphTypeVariables = Sets.empty}+      in (hoistLetBindingsWithPredicate isParentBinding shouldHoistPolymorphic emptyCx let0)+-- | Hoist subterms into local let bindings based on a path-aware predicate. The predicate receives a pair of (path, term) where path is the list of SubtermSteps from the root to the current term, and returns True if the term should be hoisted. For each let term found, the immediate subterms (binding values and body) are processed: matching subterms within each immediate subterm are collected and hoisted into a local let that wraps that immediate subterm. If a hoisted term contains free variables that are lambda-bound at an enclosing scope, the hoisted binding is wrapped in lambdas for those variables, and the reference is replaced with an application of those variables.+hoistSubterms :: (([Paths.SubtermStep], Core.Term) -> Bool) -> Graph.Graph -> Core.Term -> Core.Term+hoistSubterms shouldHoist cx0 term0 =++      let processImmediateSubterm =+              \cx -> \counter -> \namePrefix -> \pathPrefix -> \subterm ->+                let baselineLambdaVars = Graph.graphLambdaVariables cx+                    collectAndReplace =+                            \recurse -> \path -> \cxInner -> \acc -> \term ->+                              let currentCounter = Pairs.first acc+                                  collectedBindings = Pairs.second acc+                              in case term of+                                Core.TermLet _ -> (acc, term)+                                Core.TermTypeLambda _ -> (acc, term)+                                _ ->+                                  let result = recurse acc term+                                      newAcc = Pairs.first result+                                      processedTerm = Pairs.second result+                                      newCounter = Pairs.first newAcc+                                      newBindings = Pairs.second newAcc+                                      fullPath = Lists.concat2 pathPrefix path+                                  in (Logic.ifElse (shouldHoist (fullPath, processedTerm)) (+                                    let proposedName =+                                            Core.Name (Strings.cat [+                                              "_hoist_",+                                              namePrefix,+                                              "_",+                                              (Literals.showInt32 newCounter)])+                                        existingNames = Sets.fromList (Lists.map (\b -> Core.bindingName b) newBindings)+                                        freeVarsInSubterm = Variables.freeVariablesInTerm subterm+                                        allReserved = Sets.union existingNames freeVarsInSubterm+                                        bindingName = Lexical.chooseUniqueName allReserved proposedName+                                        allLambdaVars = Graph.graphLambdaVariables cxInner+                                        newLambdaVars = Sets.difference allLambdaVars baselineLambdaVars+                                        freeVars = Variables.freeVariablesInTerm processedTerm+                                        capturedVars = Sets.toList (Sets.intersection newLambdaVars freeVars)+                                        typeMap = Maps.map Scoping.typeSchemeToFType (Graph.graphBoundTypes cxInner)+                                        wrappedTerm =+                                                Lists.foldl (\body -> \varName -> Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = varName,+                                                  Core.lambdaDomain = (Maps.lookup varName typeMap),+                                                  Core.lambdaBody = body})) processedTerm (Lists.reverse capturedVars)+                                        reference =+                                                Lists.foldl (\fn -> \varName -> Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = fn,+                                                  Core.applicationArgument = (Core.TermVariable varName)})) (Core.TermVariable bindingName) capturedVars+                                        newBinding =+                                                Core.Binding {+                                                  Core.bindingName = bindingName,+                                                  Core.bindingTerm = wrappedTerm,+                                                  Core.bindingTypeScheme = Nothing}+                                    in ((Math.add newCounter 1, (Lists.cons newBinding newBindings)), reference)) (newAcc, processedTerm))+                    result = Rewriting.rewriteAndFoldTermWithGraphAndPath collectAndReplace cx (counter, []) subterm+                    finalAcc = Pairs.first result+                    transformedSubterm = Pairs.second result+                    finalCounter = Pairs.first finalAcc+                    bindings = Pairs.second finalAcc+                in (Logic.ifElse (Lists.null bindings) (finalCounter, transformedSubterm) (+                  let localLet =+                          Core.TermLet (Core.Let {+                            Core.letBindings = (Lists.reverse bindings),+                            Core.letBody = transformedSubterm})+                  in (finalCounter, localLet)))+          processLetTerm =+                  \cx -> \counter -> \path -> \lt ->+                    let bindings = Core.letBindings lt+                        body = Core.letBody lt+                        processBinding =+                                \acc -> \binding ->+                                  let namePrefix = Strings.intercalate "_" (Strings.splitOn "." (Core.unName (Core.bindingName binding)))+                                      bindingPathPrefix = Lists.concat2 path [+                                            Paths.SubtermStepLetBinding (Core.bindingName binding)]+                                      result = processImmediateSubterm cx 1 namePrefix bindingPathPrefix (Core.bindingTerm binding)+                                      newValue = Pairs.second result+                                      newBinding =+                                              Core.Binding {+                                                Core.bindingName = (Core.bindingName binding),+                                                Core.bindingTerm = newValue,+                                                Core.bindingTypeScheme = (Core.bindingTypeScheme binding)}+                                  in (Lists.cons newBinding acc)+                        newBindingsReversed = Lists.foldl processBinding [] bindings+                        newBindings = Lists.reverse newBindingsReversed+                        bodyPathPrefix = Lists.concat2 path [+                              Paths.SubtermStepLetBody]+                        firstBindingName =+                                Optionals.cases (Lists.maybeHead bindings) "body" (\b -> Strings.intercalate "_" (Strings.splitOn "." (Core.unName (Core.bindingName b))))+                        bodyPrefix = Strings.cat2 firstBindingName "_body"+                        bodyResult = processImmediateSubterm cx 1 bodyPrefix bodyPathPrefix body+                        newBody = Pairs.second bodyResult+                    in (+                      counter,+                      (Core.TermLet (Core.Let {+                        Core.letBindings = newBindings,+                        Core.letBody = newBody})))+          rewrite =+                  \recurse -> \path -> \cx -> \counter -> \term -> case term of+                    Core.TermLet _ ->+                      let recursed = recurse counter term+                          newCounter = Pairs.first recursed+                          recursedTerm = Pairs.second recursed+                      in case recursedTerm of+                        Core.TermLet v1 -> processLetTerm cx newCounter path v1+                        _ -> (newCounter, recursedTerm)+                    _ -> recurse counter term+      in (Pairs.second (Rewriting.rewriteAndFoldTermWithGraphAndPath rewrite cx0 1 term0))+-- | Check whether a SubtermStep is the applicationFunction step+isApplicationFunction :: Paths.SubtermStep -> Bool+isApplicationFunction acc =+    case acc of+      Paths.SubtermStepApplicationFunction -> True+      _ -> False+-- | Check whether a SubtermStep is the lambdaBody step+isLambdaBody :: Paths.SubtermStep -> Bool+isLambdaBody acc =+    case acc of+      Paths.SubtermStepLambdaBody -> True+      _ -> False+-- | Check if a term is a union elimination (case statement)+isUnionElimination :: Core.Term -> Bool+isUnionElimination term =+    case term of+      Core.TermCases _ -> True+      _ -> False+-- | Check if a term is an application of a union elimination (case statement applied to an argument)+isUnionEliminationApplication :: Core.Term -> Bool+isUnionEliminationApplication term =+    case term of+      Core.TermApplication v0 -> isUnionElimination (Strip.deannotateAndDetypeTerm (Core.applicationFunction v0))+      _ -> False+-- | Normalize a path for hoisting by treating immediately-applied lambdas as let bindings. Replaces [applicationFunction, lambdaBody, ...] with [letBody, ...].+normalizePathForHoisting :: [Paths.SubtermStep] -> [Paths.SubtermStep]+normalizePathForHoisting path =++      let go =+              \remaining -> Optionals.cases (Lists.uncons remaining) remaining (\uc1 ->+                let first = Pairs.first uc1+                    afterFirst = Pairs.second uc1+                in (Optionals.cases (Lists.uncons afterFirst) remaining (\uc2 ->+                  let second = Pairs.first uc2+                      rest = Pairs.second uc2+                  in (Logic.ifElse (Logic.and (isApplicationFunction first) (isLambdaBody second)) (Lists.cons Paths.SubtermStepLetBody (go rest)) (Lists.cons first (go afterFirst))))))+      in (go path)+-- | Predicate that always returns True, for hoisting all bindings unconditionally.+shouldHoistAll :: t0 -> t1 -> Bool+shouldHoistAll _ _2 = True+-- | Predicate for case statement hoisting. Returns True if term is a union elimination (bare case function) or a case statement application (union elimination applied to an argument) AND not at top level. Top level = reachable through annotations, let body/binding, lambda bodies, or ONE app LHS. Once through an app LHS, lambda bodies no longer pass through.+shouldHoistCaseStatement :: ([Paths.SubtermStep], Core.Term) -> Bool+shouldHoistCaseStatement pathAndTerm =++      let path = Pairs.first pathAndTerm+          term = Pairs.second pathAndTerm+      in (Logic.ifElse (Logic.not (Logic.or (isUnionElimination term) (isUnionEliminationApplication term))) False (+        let finalState = Lists.foldl (\st -> \acc -> updateHoistState acc st) (True, False) path+        in (Logic.not (Pairs.first finalState))))+-- | Predicate for hoisting polymorphic bindings. Returns True if the binding is polymorphic (has type scheme variables) or if its type uses any type variables from the Graph.+shouldHoistPolymorphic :: Graph.Graph -> Core.Binding -> Bool+shouldHoistPolymorphic cx binding = Logic.or (bindingIsPolymorphic binding) (bindingUsesContextTypeVars cx binding)+-- | Update hoisting state when traversing an accessor. State is (atTopLevel, usedAppLHS). Returns updated state.+updateHoistState :: Paths.SubtermStep -> (Bool, Bool) -> (Bool, Bool)+updateHoistState accessor state =++      let atTop = Pairs.first state+          usedApp = Pairs.second state+      in (Logic.ifElse (Logic.not atTop) (False, usedApp) (case accessor of+        Paths.SubtermStepAnnotatedBody -> (True, usedApp)+        Paths.SubtermStepLetBody -> (True, usedApp)+        Paths.SubtermStepLetBinding _ -> (True, usedApp)+        Paths.SubtermStepTypeApplicationTerm -> (True, usedApp)+        Paths.SubtermStepTypeLambdaBody -> (True, usedApp)+        Paths.SubtermStepLambdaBody -> Logic.ifElse usedApp (False, True) (True, False)+        Paths.SubtermStepUnionCasesBranch _ -> Logic.ifElse usedApp (False, True) (True, False)+        Paths.SubtermStepUnionCasesDefault -> Logic.ifElse usedApp (False, True) (True, False)+        Paths.SubtermStepApplicationFunction -> Logic.ifElse usedApp (False, True) (True, True)+        Paths.SubtermStepApplicationArgument -> (False, usedApp)+        _ -> (False, usedApp)))
+ src/main/haskell/Hydra/Inference.hs view
@@ -0,0 +1,1100 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Type inference for Hydra: Hindley-Milner with elaboration to System F. Extends textbook Algorithm W with nominal types, explicit type abstraction and application, and class constraints. See the Inference wiki page for the full picture.++module Hydra.Inference where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Checking as Checking+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as ErrorChecking+import qualified Hydra.Error.Core as ErrorCore+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.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Resolution as Resolution+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Show.Typing as ShowTyping+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Substitution as Substitution+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Unification as Unification+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Return the element at the given index, or Left(Other) with the given description if out of range+atOrFail :: Int -> String -> [t0] -> Either Errors.Error t0+atOrFail i desc xs =+    Optionals.cases (Lists.maybeAt i xs) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "atOrFail: " desc)))) (\x -> Right x)+-- | Unify type constraints and check the substitution+bindConstraints :: Typing.InferenceContext -> Graph.Graph -> [Typing.TypeConstraint] -> Either Errors.Error Typing.TypeSubst+bindConstraints flowCx cx constraints =+    Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorInference (Errors.InferenceErrorUnification (Errors.UnificationInferenceError {+      Errors.unificationInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace flowCx))),+      Errors.unificationInferenceErrorCause = _e}))) (\_a -> _a) (Unification.unifyTypeConstraints flowCx (Graph.graphSchemaTypes cx) constraints)) (\s -> Eithers.bind (Checking.checkTypeSubst flowCx cx s) (\_ -> Right s))+-- | Handle unbound type variables under a typed let binding. Variables appearing free in the binding's declared type (but not in schema types or the scheme's own quantified variables) are added to the scheme and the term is wrapped in matching TypeLambdas. Variables appearing only in the term body (at type-application or lambda-domain positions) are phantom — they have no external effect on the binding's type — and are substituted with hydra.core.Unit in the body rather than generalized. This keeps downstream stages from seeing vacuous foralls that target languages with non-polymorphic value bindings (e.g. Scala val) cannot express.+bindUnboundTypeVariables :: Graph.Graph -> Core.Term -> Core.Term+bindUnboundTypeVariables cx term0 =++      let svars = Sets.fromList (Maps.keys (Graph.graphSchemaTypes cx))+          rewrite =+                  \recurse -> \term -> case term of+                    Core.TermLet v0 ->+                      let forBinding =+                              \b ->+                                let bname = Core.bindingName b+                                    bterm = Core.bindingTerm b+                                in (Optionals.cases (Core.bindingTypeScheme b) (Core.Binding {+                                  Core.bindingName = bname,+                                  Core.bindingTerm = (bindUnboundTypeVariables cx bterm),+                                  Core.bindingTypeScheme = Nothing}) (\ts ->+                                  let bvars = Sets.fromList (Core.typeSchemeVariables ts)+                                      excluded = Sets.union svars bvars+                                      inType = Sets.difference (Variables.freeVariablesInType (Core.typeSchemeBody ts)) excluded+                                      phantoms = Sets.difference (Variables.freeTypeVariablesInTerm bterm) (Sets.union excluded inType)+                                      phantomSubst = Typing.TypeSubst (Maps.fromList (Lists.map (\v -> (v, Core.TypeUnit)) (Sets.toList phantoms)))+                                      bterm1 = Substitution.substTypesInTerm phantomSubst bterm+                                      unbound = Sets.toList inType+                                      ts2 =+                                              Core.TypeScheme {+                                                Core.typeSchemeVariables = (Lists.concat2 (Core.typeSchemeVariables ts) unbound),+                                                Core.typeSchemeBody = (Core.typeSchemeBody ts),+                                                Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)}+                                      bterm2 =+                                              Lists.foldl (\t -> \v -> Core.TermTypeLambda (Core.TypeLambda {+                                                Core.typeLambdaParameter = v,+                                                Core.typeLambdaBody = t})) bterm1 unbound+                                  in Core.Binding {+                                    Core.bindingName = bname,+                                    Core.bindingTerm = bterm2,+                                    Core.bindingTypeScheme = (Just ts2)}))+                      in (Core.TermLet (Core.Let {+                        Core.letBindings = (Lists.map forBinding (Core.letBindings v0)),+                        Core.letBody = (bindUnboundTypeVariables cx (Core.letBody v0))}))+                    _ -> recurse term+      in (Rewriting.rewriteTerm rewrite term0)+-- | Fold a list of type variables over a term to build a type application term+buildTypeApplicationTerm :: [Core.Name] -> Core.Term -> Core.Term+buildTypeApplicationTerm tvars body =+    Lists.foldl (\t -> \v -> Core.TermTypeApplication (Core.TypeApplicationTerm {+      Core.typeApplicationTermBody = t,+      Core.typeApplicationTermType = (Core.TypeVariable v)})) body tvars+-- | Add (term variable, type scheme) pairs to the graph's bound types+extendContext :: [(Core.Name, Core.TypeScheme)] -> Graph.Graph -> Graph.Graph+extendContext pairs cx =+    Graph.Graph {+      Graph.graphBoundTerms = (Graph.graphBoundTerms cx),+      Graph.graphBoundTypes = (Maps.union (Maps.fromList pairs) (Graph.graphBoundTypes cx)),+      Graph.graphClassConstraints = (Graph.graphClassConstraints cx),+      Graph.graphLambdaVariables = (Graph.graphLambdaVariables cx),+      Graph.graphMetadata = (Graph.graphMetadata cx),+      Graph.graphPrimitives = (Graph.graphPrimitives cx),+      Graph.graphSchemaTypes = (Graph.graphSchemaTypes cx),+      Graph.graphTypeVariables = (Graph.graphTypeVariables cx)}+-- | Finalize an inferred term by checking for unbound type variables, then normalizing type variables+finalizeInferredTerm :: t0 -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+finalizeInferredTerm flowCx cx term =++      let term2 = bindUnboundTypeVariables cx term+      in (Eithers.bind (Checking.checkForUnboundTypeVariables flowCx cx term2) (\_ -> Right (Variables.normalizeTypeVariablesInTerm term2)))+-- | Infer a term's type and map over the result+forInferredTerm :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> String -> (Typing.InferenceResult -> t0) -> Either Errors.Error (t0, Typing.InferenceContext)+forInferredTerm fcx cx term desc f =+    Eithers.bind (inferTypeOfTerm fcx cx term desc) (\rp -> Right (f rp, (Typing.inferenceResultContext rp)))+-- | Get all free variables in a graph's bound types+freeVariablesInContext :: Graph.Graph -> S.Set Core.Name+freeVariablesInContext cx =+    Lists.foldl Sets.union Sets.empty (Lists.map Variables.freeVariablesInTypeSchemeSimple (Maps.elems (Graph.graphBoundTypes cx)))+-- | Generate a fresh type variable+freshVariableType :: Typing.InferenceContext -> (Core.Type, Typing.InferenceContext)+freshVariableType cx =++      let result = Names.freshName cx+          name = Pairs.first result+          cx2 = Pairs.second result+      in (Core.TypeVariable name, cx2)+-- | Generalize a type to a type scheme+generalize :: Graph.Graph -> Core.Type -> Core.TypeScheme+generalize cx typ =++      let isTypeVarName =+              \name ->+                let parts = Strings.splitOn "." (Core.unName name)+                in (Equality.lte (Lists.length parts) 1)+          vars =+                  Lists.nub (Lists.filter (\v -> Logic.and (isUnbound cx v) (isTypeVarName v)) (Variables.freeVariablesInTypeOrdered typ))+          allConstraints = Graph.graphClassConstraints cx+          relevantConstraints =+                  Maps.fromList (Optionals.cat (Lists.map (\v -> Optionals.map (\meta -> (v, meta)) (Maps.lookup v allConstraints)) vars))+          constraintsMaybe = Logic.ifElse (Maps.null relevantConstraints) Nothing (Just relevantConstraints)+      in Core.TypeScheme {+        Core.typeSchemeVariables = vars,+        Core.typeSchemeBody = typ,+        Core.typeSchemeConstraints = constraintsMaybe}+-- | Return the first element of a list, or Left(Other) with the given description if the list is empty+headOrFail :: String -> [t0] -> Either Errors.Error t0+headOrFail desc xs =+    Optionals.cases (Lists.maybeHead xs) (Left (Errors.ErrorOther (Errors.OtherError (Strings.cat2 "headOrFail: " desc)))) (\x -> Right x)+-- | Infer types for all elements in a graph, using the provided ordered bindings. Returns both the inferred graph and the ordered inferred bindings.+inferGraphTypes :: Typing.InferenceContext -> [Core.Binding] -> Graph.Graph -> Either Errors.Error ((Graph.Graph, [Core.Binding]), Typing.InferenceContext)+inferGraphTypes fcx0 bindings0 g0 =++      let fcx = fcx0+          let0 =+                  Core.Let {+                    Core.letBindings = bindings0,+                    Core.letBody = Core.TermUnit}+          fromLetTerm =+                  \l ->+                    let bindings = Core.letBindings l+                        prims = Graph.graphPrimitives g0+                        schemaTypes = Graph.graphSchemaTypes g0+                        rawG = Lexical.buildGraph bindings Maps.empty prims+                        g =+                                Graph.Graph {+                                  Graph.graphBoundTerms = (Graph.graphBoundTerms rawG),+                                  Graph.graphBoundTypes = (Graph.graphBoundTypes rawG),+                                  Graph.graphClassConstraints = (Graph.graphClassConstraints rawG),+                                  Graph.graphLambdaVariables = (Graph.graphLambdaVariables rawG),+                                  Graph.graphMetadata = (Graph.graphMetadata rawG),+                                  Graph.graphPrimitives = (Graph.graphPrimitives rawG),+                                  Graph.graphSchemaTypes = schemaTypes,+                                  Graph.graphTypeVariables = (Graph.graphTypeVariables rawG)}+                    in (g, bindings)+      in (Eithers.bind (inferTypeOfTerm fcx g0 (Core.TermLet let0) "graph term") (\result ->+        let fcx2 = Typing.inferenceResultContext result+            term = Typing.inferenceResultTerm result+        in (Eithers.bind (finalizeInferredTerm fcx2 g0 term) (\finalized -> case finalized of+          Core.TermLet v0 -> Right (fromLetTerm v0, fcx2)+          Core.TermVariable _ -> Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {+            Errors.otherInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx2))),+            Errors.otherInferenceErrorMessage = "Expected inferred graph as let term"})))))))+-- | Infer the type of a term in a given inference context+inferInGraphContext :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error Typing.InferenceResult+inferInGraphContext fcx cx term = inferTypeOfTerm fcx cx term "single term"+-- | Infer types for multiple terms, propagating class constraints from sub-expressions+inferMany :: Typing.InferenceContext -> Graph.Graph -> [(Core.Term, String)] -> Either Errors.Error (+  ([Core.Term], ([Core.Type], (Typing.TypeSubst, (M.Map Core.Name Core.TypeVariableConstraints)))),+  Typing.InferenceContext)+inferMany fcx cx pairs =++      let emptyResult = Right (([], ([], (Substitution.idTypeSubst, Maps.empty))), fcx)+      in (Optionals.cases (Lists.uncons pairs) emptyResult (\pairsUc ->+        let headPair = Pairs.first pairsUc+            tl = Pairs.second pairsUc+            e = Pairs.first headPair+            desc = Pairs.second headPair+        in (Eithers.bind (inferTypeOfTerm fcx cx e desc) (\result1 ->+          let fcx2 = Typing.inferenceResultContext result1+              e1 = Typing.inferenceResultTerm result1+              t1 = Typing.inferenceResultType result1+              s1 = Typing.inferenceResultSubst result1+              c1 = Typing.inferenceResultClassConstraints result1+          in (Eithers.bind (inferMany fcx2 (Substitution.substInContext s1 cx) tl) (\rp2 ->+            let result2 = Pairs.first rp2+                fcx3 = Pairs.second rp2+                e2 = Pairs.first result2+                t2 = Pairs.first (Pairs.second result2)+                s2 = Pairs.first (Pairs.second (Pairs.second result2))+                c2 = Pairs.second (Pairs.second (Pairs.second result2))+                c1Subst = Substitution.substInClassConstraints s2 c1+                mergedConstraints = mergeClassConstraints c1Subst c2+            in (Right (+              (+                Lists.cons (Substitution.substTypesInTerm s2 e1) e2,+                (Lists.cons (Substitution.substInType s2 t1) t2, (Substitution.composeTypeSubst s1 s2, mergedConstraints))),+              fcx3))))))))+-- | Map a possibly untyped term to a fully typed term and its type+inferTypeOf :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error ((Core.Term, Core.TypeScheme), Typing.InferenceContext)+inferTypeOf fcx cx term =++      let letTerm =+              Core.TermLet (Core.Let {+                Core.letBindings = [+                  Core.Binding {+                    Core.bindingName = (Core.Name "ignoredVariableName"),+                    Core.bindingTerm = term,+                    Core.bindingTypeScheme = Nothing}],+                Core.letBody = (Core.TermLiteral (Core.LiteralString "ignoredBody"))})+      in (Eithers.bind (inferTypeOfTerm fcx cx letTerm "infer type of term") (\result ->+        let fcx2 = Typing.inferenceResultContext result+        in (Eithers.bind (finalizeInferredTerm fcx2 cx (Typing.inferenceResultTerm result)) (\finalized -> Eithers.bind (ExtractCore.let_ cx finalized) (\letResult ->+          let bindings = Core.letBindings letResult+          in (Logic.ifElse (Equality.equal 1 (Lists.length bindings)) (Eithers.bind (headOrFail "inferTypeOf: single binding expected" bindings) (\binding ->+            let term1 = Core.bindingTerm binding+                mts = Core.bindingTypeScheme binding+            in (Optionals.cases mts (Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {+              Errors.otherInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx2))),+              Errors.otherInferenceErrorMessage = "Expected a type scheme"})))) (\ts -> Right ((term1, ts), fcx2))))) (Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {+            Errors.otherInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx2))),+            Errors.otherInferenceErrorMessage = (Strings.cat [+              "Expected a single binding with a type scheme, but got: ",+              (Literals.showInt32 (Lists.length bindings)),+              " bindings"])}))))))))))+-- | Infer the type of an annotated term (Either version)+inferTypeOfAnnotatedTerm :: Typing.InferenceContext -> Graph.Graph -> Core.AnnotatedTerm -> Either Errors.Error Typing.InferenceResult+inferTypeOfAnnotatedTerm fcx cx at =++      let term = Core.annotatedTermBody at+          ann = Core.annotatedTermAnnotation at+          fcxBody = Names.pushSubtermStep Paths.SubtermStepAnnotatedBody fcx+      in (Eithers.bind (inferTypeOfTerm fcxBody cx term "annotated term") (\result ->+        let fcx2 = Names.restoreTrace fcx (Typing.inferenceResultContext result)+            iterm = Typing.inferenceResultTerm result+            itype = Typing.inferenceResultType result+            isubst = Typing.inferenceResultSubst result+            iconstraints = Typing.inferenceResultClassConstraints result+        in (Right (Typing.InferenceResult {+          Typing.inferenceResultTerm = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = iterm,+            Core.annotatedTermAnnotation = ann})),+          Typing.inferenceResultType = itype,+          Typing.inferenceResultSubst = isubst,+          Typing.inferenceResultClassConstraints = iconstraints,+          Typing.inferenceResultContext = fcx2}))))+-- | Infer the type of a function application (Either version)+inferTypeOfApplication :: Typing.InferenceContext -> Graph.Graph -> Core.Application -> Either Errors.Error Typing.InferenceResult+inferTypeOfApplication fcx0 cx app =++      let e0 = Core.applicationFunction app+          e1 = Core.applicationArgument app+          fcxFun = Names.pushSubtermStep Paths.SubtermStepApplicationFunction fcx0+      in (Eithers.bind (inferTypeOfTerm fcxFun cx e0 "lhs") (\lhsResult ->+        let fcx2 = Names.restoreTrace fcx0 (Typing.inferenceResultContext lhsResult)+            a = Typing.inferenceResultTerm lhsResult+            t0 = Typing.inferenceResultType lhsResult+            s0 = Typing.inferenceResultSubst lhsResult+            c0 = Typing.inferenceResultClassConstraints lhsResult+            fcxArg = Names.pushSubtermStep Paths.SubtermStepApplicationArgument fcx2+        in (Eithers.bind (inferTypeOfTerm fcxArg (Substitution.substInContext s0 cx) e1 "rhs") (\rhsResult ->+          let fcx3 = Names.restoreTrace fcx0 (Typing.inferenceResultContext rhsResult)+              b = Typing.inferenceResultTerm rhsResult+              t1 = Typing.inferenceResultType rhsResult+              s1 = Typing.inferenceResultSubst rhsResult+              c1 = Typing.inferenceResultClassConstraints rhsResult+              vResult = Names.freshName fcx3+              v = Pairs.first vResult+              fcx4 = Pairs.second vResult+          in (Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorInference (Errors.InferenceErrorUnification (Errors.UnificationInferenceError {+            Errors.unificationInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx4))),+            Errors.unificationInferenceErrorCause = _e}))) (\_a -> _a) (Unification.unifyTypes fcx4 (Graph.graphSchemaTypes cx) (Substitution.substInType s1 t0) (Core.TypeFunction (Core.FunctionType {+            Core.functionTypeDomain = t1,+            Core.functionTypeCodomain = (Core.TypeVariable v)})) "application lhs")) (\s2 -> Eithers.bind (Checking.checkTypeSubst fcx4 cx s2) (\_ ->+            let rExpr =+                    Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Substitution.substTypesInTerm (Substitution.composeTypeSubst s1 s2) a),+                      Core.applicationArgument = (Substitution.substTypesInTerm s2 b)})+                rType = Substitution.substInType s2 (Core.TypeVariable v)+                rSubst =+                        Substitution.composeTypeSubstList [+                          s0,+                          s1,+                          s2]+                c0Subst = Substitution.substInClassConstraints s2 (Substitution.substInClassConstraints s1 c0)+                c1Subst = Substitution.substInClassConstraints s2 c1+                rConstraints = mergeClassConstraints c0Subst c1Subst+            in (Right (Typing.InferenceResult {+              Typing.inferenceResultTerm = rExpr,+              Typing.inferenceResultType = rType,+              Typing.inferenceResultSubst = rSubst,+              Typing.inferenceResultClassConstraints = rConstraints,+              Typing.inferenceResultContext = fcx4})))))))))+-- | Infer the type of a case statement (Either version)+inferTypeOfCaseStatement :: Typing.InferenceContext -> Graph.Graph -> Core.CaseStatement -> Either Errors.Error Typing.InferenceResult+inferTypeOfCaseStatement fcx cx caseStmt =++      let tname = Core.caseStatementTypeName caseStmt+          dflt = Core.caseStatementDefault caseStmt+          cases = Core.caseStatementCases caseStmt+          fnames = Lists.map Core.caseAlternativeName cases+      in (Eithers.bind (Resolution.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp ->+        let schemaType = Pairs.first stRp+            fcx2 = Pairs.second stRp+            svars = Core.typeSchemeVariables schemaType+            stype = Core.typeSchemeBody schemaType+        in (Eithers.bind (ExtractCore.unionType tname stype) (\sfields ->+          let fcxDflt = Names.pushSubtermStep Paths.SubtermStepUnionCasesDefault fcx2+          in (Eithers.bind (Eithers.mapOptional (\t -> inferTypeOfTerm fcxDflt cx t (Strings.cat [+            "case ",+            (Core.unName tname),+            ".<default>"])) dflt) (\dfltRp ->+            let dfltResult = dfltRp+                fcx3 =+                        Optionals.fromOptional fcx2 (Optionals.map (\_r -> Names.restoreTrace fcx2 (Typing.inferenceResultContext _r)) dfltRp)+            in (Eithers.bind (inferMany fcx3 cx (Lists.map (\f -> (+              Core.caseAlternativeHandler f,+              (Strings.cat [+                "case ",+                (Core.unName tname),+                ".",+                (Core.unName (Core.caseAlternativeName f))]))) cases)) (\caseRp ->+              let caseResults = Pairs.first caseRp+                  fcx4 = Pairs.second caseRp+                  iterms = Pairs.first caseResults+                  itypes = Pairs.first (Pairs.second caseResults)+                  isubst = Pairs.first (Pairs.second (Pairs.second caseResults))+                  caseElemConstraints = Pairs.second (Pairs.second (Pairs.second caseResults))+                  codvResult = Names.freshName fcx4+                  codv = Pairs.first codvResult+                  fcx5 = Pairs.second codvResult+                  cod = Core.TypeVariable codv+                  caseMap = Maps.fromList (Lists.map (\ft -> (Core.fieldTypeName ft, (Core.fieldTypeType ft))) sfields)+                  dfltConstraints =+                          Optionals.toList (Optionals.map (\r -> Typing.TypeConstraint {+                            Typing.typeConstraintLeft = cod,+                            Typing.typeConstraintRight = (Substitution.substInType isubst (Typing.inferenceResultType r)),+                            Typing.typeConstraintComment = "match default"}) dfltResult)+                  caseConstraints =+                          Optionals.cat (Lists.zipWith (\fname -> \itype -> Optionals.map (\ftype -> Typing.TypeConstraint {+                            Typing.typeConstraintLeft = itype,+                            Typing.typeConstraintRight = (Core.TypeFunction (Core.FunctionType {+                              Core.functionTypeDomain = ftype,+                              Core.functionTypeCodomain = cod})),+                            Typing.typeConstraintComment = "case type"}) (Maps.lookup fname caseMap)) fnames itypes)+                  dfltClassConstraints = Optionals.fromOptional Maps.empty (Optionals.map Typing.inferenceResultClassConstraints dfltResult)+                  allElemConstraints = mergeClassConstraints caseElemConstraints dfltClassConstraints+              in (Eithers.bind (mapConstraints fcx5 cx (\subst -> yieldWithConstraints fcx5 (buildTypeApplicationTerm svars (Core.TermCases (Core.CaseStatement {+                Core.caseStatementTypeName = tname,+                Core.caseStatementDefault = (Optionals.map Typing.inferenceResultTerm dfltResult),+                Core.caseStatementCases = (Lists.zipWith (\n -> \t -> Core.CaseAlternative {+                  Core.caseAlternativeName = n,+                  Core.caseAlternativeHandler = t}) fnames iterms)}))) (Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Resolution.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)),+                Core.functionTypeCodomain = cod})) (Substitution.composeTypeSubstList (Lists.concat [+                Optionals.toList (Optionals.map Typing.inferenceResultSubst dfltResult),+                [+                  isubst,+                  subst]])) (Substitution.substInClassConstraints subst allElemConstraints)) (Lists.concat [+                dfltConstraints,+                caseConstraints])) (\mcResult -> Right mcResult))))))))))+-- | Infer the type of a collection. The classNames parameter specifies type classes (e.g. ordering) that the element type variable must satisfy.+inferTypeOfCollection :: Typing.InferenceContext -> Graph.Graph -> (Core.Type -> Core.Type) -> ([Core.Term] -> Core.Term) -> String -> S.Set Core.Name -> [Core.Term] -> Either Errors.Error Typing.InferenceResult+inferTypeOfCollection fcx cx typCons trmCons desc classNames els =++      let varResult = Names.freshName fcx+          var = Pairs.first varResult+          fcx2 = Pairs.second varResult+          classConstraints =+                  Logic.ifElse (Sets.null classNames) Maps.empty (Maps.singleton var (Core.TypeVariableConstraints {+                    Core.typeVariableConstraintsClasses = (Lists.map (\n -> Core.TypeClassConstraintSimple n) (Sets.toList classNames))}))+      in (Logic.ifElse (Lists.null els) (Right (yieldWithConstraints fcx2 (buildTypeApplicationTerm [+        var] (trmCons [])) (typCons (Core.TypeVariable var)) Substitution.idTypeSubst classConstraints)) (Eithers.bind (inferMany fcx2 cx (Lists.zip els (Lists.map (\i -> Strings.cat [+        "#",+        (Literals.showInt32 i)]) (Math.range 1 (Math.add (Lists.length els) 1))))) (\resultsRp ->+        let results = Pairs.first resultsRp+            fcx3 = Pairs.second resultsRp+            terms = Pairs.first results+            types = Pairs.first (Pairs.second results)+            subst1 = Pairs.first (Pairs.second (Pairs.second results))+            elemConstraints = Pairs.second (Pairs.second (Pairs.second results))+            constraints =+                    Lists.map (\t -> Typing.TypeConstraint {+                      Typing.typeConstraintLeft = (Core.TypeVariable var),+                      Typing.typeConstraintRight = t,+                      Typing.typeConstraintComment = desc}) types+            allConstraints = mergeClassConstraints classConstraints elemConstraints+        in (Eithers.bind (mapConstraints fcx3 cx (\subst2 ->+          let iterm = trmCons terms+              itype = typCons (Core.TypeVariable var)+              isubst = Substitution.composeTypeSubst subst1 subst2+          in (yieldWithConstraints fcx3 iterm itype isubst (Substitution.substInClassConstraints subst2 allConstraints))) constraints) (\mcResult -> Right mcResult)))))+-- | Infer the type of an either value (Either version)+inferTypeOfEither :: Typing.InferenceContext -> Graph.Graph -> Either Core.Term Core.Term -> Either Errors.Error Typing.InferenceResult+inferTypeOfEither fcx cx e =+    Eithers.either (\l -> Eithers.bind (inferTypeOfTerm fcx cx l "either left value") (\r1 ->+      let fcx2 = Typing.inferenceResultContext r1+          iterm = Typing.inferenceResultTerm r1+          leftType = Typing.inferenceResultType r1+          subst = Typing.inferenceResultSubst r1+          fvResult = freshVariableType fcx2+          rightType = Pairs.first fvResult+          fcx3 = Pairs.second fvResult+          eitherTerm = Core.TermEither (Left iterm)+          termWithLeftType =+                  Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = eitherTerm,+                    Core.typeApplicationTermType = leftType})+          termWithBothTypes =+                  Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = termWithLeftType,+                    Core.typeApplicationTermType = rightType})+          eitherType =+                  Core.TypeEither (Core.EitherType {+                    Core.eitherTypeLeft = leftType,+                    Core.eitherTypeRight = rightType})+      in (Right (yieldChecked fcx3 termWithBothTypes eitherType subst)))) (\r -> Eithers.bind (inferTypeOfTerm fcx cx r "either right value") (\r1 ->+      let fcx2 = Typing.inferenceResultContext r1+          iterm = Typing.inferenceResultTerm r1+          rightType = Typing.inferenceResultType r1+          subst = Typing.inferenceResultSubst r1+          fvResult = freshVariableType fcx2+          leftType = Pairs.first fvResult+          fcx3 = Pairs.second fvResult+          eitherTerm = Core.TermEither (Right iterm)+          termWithLeftType =+                  Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = eitherTerm,+                    Core.typeApplicationTermType = leftType})+          termWithBothTypes =+                  Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = termWithLeftType,+                    Core.typeApplicationTermType = rightType})+          eitherType =+                  Core.TypeEither (Core.EitherType {+                    Core.eitherTypeLeft = leftType,+                    Core.eitherTypeRight = rightType})+      in (Right (yieldChecked fcx3 termWithBothTypes eitherType subst)))) e+-- | Infer the type of a union injection (Either version)+inferTypeOfInjection :: Typing.InferenceContext -> Graph.Graph -> Core.Injection -> Either Errors.Error Typing.InferenceResult+inferTypeOfInjection fcx cx injection =++      let tname = Core.injectionTypeName injection+          field = Core.injectionField injection+          fname = Core.fieldName field+          term = Core.fieldTerm field+          fcxInj = Names.pushSubtermStep Paths.SubtermStepSumTerm fcx+      in (Eithers.bind (inferTypeOfTerm fcxInj cx term "injected term") (\result ->+        let fcx2 = Names.restoreTrace fcx (Typing.inferenceResultContext result)+        in (Eithers.bind (Resolution.requireSchemaType fcx2 (Graph.graphSchemaTypes cx) tname) (\stRp ->+          let schemaType = Pairs.first stRp+              fcx3 = Pairs.second stRp+              svars = Core.typeSchemeVariables schemaType+              stype = Core.typeSchemeBody schemaType+              iterm = Typing.inferenceResultTerm result+              ityp = Typing.inferenceResultType result+              isubst = Typing.inferenceResultSubst result+          in (Eithers.bind (ExtractCore.unionType tname stype) (\sfields -> Eithers.bind (Resolution.findFieldType fcx3 fname sfields) (\ftyp -> Eithers.bind (mapConstraints fcx3 cx (\subst -> yield fcx3 (buildTypeApplicationTerm svars (Core.TermInject (Core.Injection {+            Core.injectionTypeName = tname,+            Core.injectionField = Core.Field {+              Core.fieldName = fname,+              Core.fieldTerm = iterm}}))) (Resolution.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)) (Substitution.composeTypeSubst isubst subst)) [+            Typing.TypeConstraint {+              Typing.typeConstraintLeft = ftyp,+              Typing.typeConstraintRight = ityp,+              Typing.typeConstraintComment = "schema type of injected field"}]) (\mcResult -> Right mcResult))))))))+-- | Infer the type of a lambda function (Either version)+inferTypeOfLambda :: Typing.InferenceContext -> Graph.Graph -> Core.Lambda -> Either Errors.Error Typing.InferenceResult+inferTypeOfLambda fcx cx lambda =++      let var = Core.lambdaParameter lambda+          body = Core.lambdaBody lambda+          vdomResult = Names.freshName fcx+          vdom = Pairs.first vdomResult+          fcx2 = Pairs.second vdomResult+          dom = Core.TypeVariable vdom+          cx2 =+                  extendContext [+                    (+                      var,+                      Core.TypeScheme {+                        Core.typeSchemeVariables = [],+                        Core.typeSchemeBody = dom,+                        Core.typeSchemeConstraints = Nothing})] cx+          fcxBody = Names.pushSubtermStep Paths.SubtermStepLambdaBody fcx2+      in (Eithers.bind (inferTypeOfTerm fcxBody cx2 body "lambda body") (\result ->+        let fcx3 = Names.restoreTrace fcx2 (Typing.inferenceResultContext result)+            iterm = Typing.inferenceResultTerm result+            icod = Typing.inferenceResultType result+            isubst = Typing.inferenceResultSubst result+            rdom = Substitution.substInType isubst dom+            rterm =+                    Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = var,+                      Core.lambdaDomain = (Just rdom),+                      Core.lambdaBody = iterm})+            rtype =+                    Core.TypeFunction (Core.FunctionType {+                      Core.functionTypeDomain = rdom,+                      Core.functionTypeCodomain = icod})+            vars =+                    Sets.unions [+                      Variables.freeVariablesInType rdom,+                      (Variables.freeVariablesInType icod),+                      (freeVariablesInContext (Substitution.substInContext isubst cx2))]+            cx3 = Substitution.substInContext isubst cx+            iconstraints = Substitution.substInClassConstraints isubst (Typing.inferenceResultClassConstraints result)+        in (Right (Typing.InferenceResult {+          Typing.inferenceResultTerm = rterm,+          Typing.inferenceResultType = rtype,+          Typing.inferenceResultSubst = isubst,+          Typing.inferenceResultClassConstraints = iconstraints,+          Typing.inferenceResultContext = fcx3}))))+-- | Normalize a let term before inferring its type (Either version). The bindings are partitioned into strongly connected components and reorganized as nested lets, one let per SCC, in dependency order. This is the standard Hindley-Milner treatment of mutual recursion: each SCC is generalized once at its boundary (sound, because nothing inside the cluster sees a polymorphic instance of its siblings), and acyclic bindings generalize individually as usual.+inferTypeOfLet :: Typing.InferenceContext -> Graph.Graph -> Core.Let -> Either Errors.Error Typing.InferenceResult+inferTypeOfLet fcx0 cx let0 =++      let fcx = fcx0+          bindings0 = Core.letBindings let0+          body0 = Core.letBody let0+          names = Lists.map Core.bindingName bindings0+          nameSet = Sets.fromList names+          toPair =+                  \binding ->+                    let name = Core.bindingName binding+                        term = Core.bindingTerm binding+                    in (name, (Lists.filter (\n -> Sets.member n nameSet) (Sets.toList (Variables.freeVariablesInTerm term))))+          adjList = Lists.map toPair bindings0+          groups = Sorting.topologicalSortComponents adjList+          bindingMap = Maps.fromList (Lists.zip names bindings0)+          createLet =+                  \e -> \group -> Core.TermLet (Core.Let {+                    Core.letBindings = (Optionals.cat (Lists.map (\n -> Maps.lookup n bindingMap) group)),+                    Core.letBody = e})+          rewrittenLet = Lists.foldl createLet body0 (Lists.reverse groups)+          restoreLet =+                  \iterm ->+                    let helper =+                            \level -> \bins -> \term ->+                              let nonzero =+                                      \term2 -> case term2 of+                                        Core.TermLet v0 ->+                                          let bs = Core.letBindings v0+                                              letBody = Core.letBody v0+                                          in (helper (Math.sub level 1) (Lists.concat [+                                            bs,+                                            bins]) letBody)+                              in (Logic.ifElse (Equality.equal level 0) (bins, term) (nonzero term))+                        result = helper (Lists.length groups) [] iterm+                        bindingList = Pairs.first result+                        e = Pairs.second result+                        bindingMap2 = Maps.fromList (Lists.map (\b -> (Core.bindingName b, b)) bindingList)+                    in (Core.TermLet (Core.Let {+                      Core.letBindings = (Optionals.cat (Lists.map (\n -> Maps.lookup n bindingMap2) names)),+                      Core.letBody = e}))+          rewriteResult =+                  \iresult ->+                    let fcxR = Typing.inferenceResultContext iresult+                        iterm = Typing.inferenceResultTerm iresult+                        itype = Typing.inferenceResultType iresult+                        isubst = Typing.inferenceResultSubst iresult+                        iconstraints = Typing.inferenceResultClassConstraints iresult+                    in Typing.InferenceResult {+                      Typing.inferenceResultTerm = (restoreLet iterm),+                      Typing.inferenceResultType = itype,+                      Typing.inferenceResultSubst = isubst,+                      Typing.inferenceResultClassConstraints = iconstraints,+                      Typing.inferenceResultContext = fcxR}+          res =+                  case rewrittenLet of+                    Core.TermLet v0 -> inferTypeOfLetNormalized fcx cx v0+                    _ -> inferTypeOfTerm fcx cx rewrittenLet "empty let term"+      in (Eithers.map rewriteResult res)+-- | Infer the type of a let (letrec) term which is already in a normal form (Either version)+inferTypeOfLetNormalized :: Typing.InferenceContext -> Graph.Graph -> Core.Let -> Either Errors.Error Typing.InferenceResult+inferTypeOfLetNormalized fcx0 cx0 letTerm =++      let fcx = fcx0+          bins0 = Core.letBindings letTerm+          body0 = Core.letBody letTerm+          bnames = Lists.map Core.bindingName bins0+          bvarsResult = Names.freshNames (Lists.length bins0) fcx+          bvars = Pairs.first bvarsResult+          fcx2 = Pairs.second bvarsResult+          tbins0 = Lists.map (\x -> Core.TypeVariable x) bvars+          cx1 =+                  extendContext (Lists.zip bnames (Lists.map (\t -> Core.TypeScheme {+                    Core.typeSchemeVariables = [],+                    Core.typeSchemeBody = t,+                    Core.typeSchemeConstraints = Nothing}) tbins0)) cx0+      in (Eithers.bind (inferTypesOfTemporaryBindings fcx2 cx1 bins0) (\irRp ->+        let inferredResult = Pairs.first irRp+            fcx3 = Pairs.second irRp+            bterms1 = Pairs.first inferredResult+            tbins1 = Pairs.first (Pairs.second inferredResult)+            substAndConstraints = Pairs.second (Pairs.second inferredResult)+            s1 = Pairs.first substAndConstraints+            inferredConstraints = Pairs.second substAndConstraints+        in (Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorInference (Errors.InferenceErrorUnification (Errors.UnificationInferenceError {+          Errors.unificationInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx3))),+          Errors.unificationInferenceErrorCause = _e}))) (\_a -> _a) (Unification.unifyTypeLists fcx3 (Graph.graphSchemaTypes cx0) (Lists.map (Substitution.substInType s1) tbins0) tbins1 "temporary type bindings")) (\s2 -> Eithers.bind (Checking.checkTypeSubst fcx3 cx0 s2) (\_ ->+          let g2base = Substitution.substInContext (Substitution.composeTypeSubst s1 s2) cx0+              constraintsWithS2 = Substitution.substInClassConstraints s2 inferredConstraints+              composedSubst = Substitution.composeTypeSubst s1 s2+              originalBindingConstraints =+                      Lists.foldl (\acc -> \b -> Optionals.cases (Core.bindingTypeScheme b) acc (\ts -> Optionals.cases (Core.typeSchemeConstraints ts) acc (\c -> mergeClassConstraints acc c))) Maps.empty bins0+              originalConstraintsSubst = Substitution.substInClassConstraints composedSubst originalBindingConstraints+              allInferredConstraints = mergeClassConstraints constraintsWithS2 originalConstraintsSubst+              mergedConstraints = mergeClassConstraints (Graph.graphClassConstraints g2base) allInferredConstraints+              g2 =+                      Graph.Graph {+                        Graph.graphBoundTerms = (Graph.graphBoundTerms g2base),+                        Graph.graphBoundTypes = (Graph.graphBoundTypes g2base),+                        Graph.graphClassConstraints = mergedConstraints,+                        Graph.graphLambdaVariables = (Graph.graphLambdaVariables g2base),+                        Graph.graphMetadata = (Graph.graphMetadata g2base),+                        Graph.graphPrimitives = (Graph.graphPrimitives g2base),+                        Graph.graphSchemaTypes = (Graph.graphSchemaTypes g2base),+                        Graph.graphTypeVariables = (Graph.graphTypeVariables g2base)}+              bterms1Subst = Lists.map (Substitution.substTypesInTerm s2) bterms1+              tsbins1 = Lists.zip bnames (Lists.map (\t -> generalize g2 (Substitution.substInType s2 t)) tbins1)+              fcx3Body = Names.pushSubtermStep Paths.SubtermStepLetBody fcx3+          in (Eithers.bind (inferTypeOfTerm fcx3Body (extendContext tsbins1 g2) body0 "let body") (\bodyResult ->+            let fcx4 = Names.restoreTrace fcx3 (Typing.inferenceResultContext bodyResult)+                body1 = Typing.inferenceResultTerm bodyResult+                tbody = Typing.inferenceResultType bodyResult+                sbody = Typing.inferenceResultSubst bodyResult+                st1 =+                        Typing.TermSubst (Maps.fromList (Lists.map (\pair ->+                          let name = Pairs.first pair+                              ts = Pairs.second pair+                          in (name, (buildTypeApplicationTerm (Core.typeSchemeVariables ts) (Core.TermVariable name)))) tsbins1))+                createBinding =+                        \bindingPair ->+                          let nameTsPair = Pairs.first bindingPair+                              term = Pairs.second bindingPair+                              name = Pairs.first nameTsPair+                              ts = Pairs.second nameTsPair+                              finalTs = Substitution.substInTypeScheme sbody ts+                              typeLambdaTerm =+                                      Lists.foldl (\b -> \v -> Core.TermTypeLambda (Core.TypeLambda {+                                        Core.typeLambdaParameter = v,+                                        Core.typeLambdaBody = b})) (Substitution.substituteInTerm st1 term) (Lists.reverse (Core.typeSchemeVariables finalTs))+                          in Core.Binding {+                            Core.bindingName = name,+                            Core.bindingTerm = (Substitution.substTypesInTerm (Substitution.composeTypeSubst sbody s2) typeLambdaTerm),+                            Core.bindingTypeScheme = (Just finalTs)}+                bins1 = Lists.map createBinding (Lists.zip tsbins1 bterms1Subst)+                bodyConstraints = Substitution.substInClassConstraints sbody (Typing.inferenceResultClassConstraints bodyResult)+                bindingConstraintsSubst = Substitution.substInClassConstraints sbody constraintsWithS2+                allConstraints = mergeClassConstraints bindingConstraintsSubst bodyConstraints+            in (Right (Typing.InferenceResult {+              Typing.inferenceResultTerm = (Core.TermLet (Core.Let {+                Core.letBindings = bins1,+                Core.letBody = body1})),+              Typing.inferenceResultType = tbody,+              Typing.inferenceResultSubst = (Substitution.composeTypeSubstList [+                s1,+                s2,+                sbody]),+              Typing.inferenceResultClassConstraints = allConstraints,+              Typing.inferenceResultContext = fcx4})))))))))+-- | Infer the type of a list (Either version)+inferTypeOfList :: Typing.InferenceContext -> Graph.Graph -> [Core.Term] -> Either Errors.Error Typing.InferenceResult+inferTypeOfList fcx cx =+    inferTypeOfCollection fcx cx (\x -> Core.TypeList x) (\x -> Core.TermList x) "list element" Sets.empty+-- | Infer the type of a literal+inferTypeOfLiteral :: Typing.InferenceContext -> Core.Literal -> Typing.InferenceResult+inferTypeOfLiteral fcx lit =+    Typing.InferenceResult {+      Typing.inferenceResultTerm = (Core.TermLiteral lit),+      Typing.inferenceResultType = (Core.TypeLiteral (Reflect.literalType lit)),+      Typing.inferenceResultSubst = Substitution.idTypeSubst,+      Typing.inferenceResultClassConstraints = Maps.empty,+      Typing.inferenceResultContext = fcx}+-- | Infer the type of a map (Either version)+inferTypeOfMap :: Typing.InferenceContext -> Graph.Graph -> M.Map Core.Term Core.Term -> Either Errors.Error Typing.InferenceResult+inferTypeOfMap fcx cx m =++      let kvarResult = Names.freshName fcx+          kvar = Pairs.first kvarResult+          fcx2 = Pairs.second kvarResult+          vvarResult = Names.freshName fcx2+          vvar = Pairs.first vvarResult+          fcx3 = Pairs.second vvarResult+          keyConstraints =+                  Maps.singleton kvar (Core.TypeVariableConstraints {+                    Core.typeVariableConstraintsClasses = [+                      Core.TypeClassConstraintSimple (Core.Name "ordering")]})+      in (Logic.ifElse (Maps.null m) (Right (yieldWithConstraints fcx3 (buildTypeApplicationTerm [+        kvar,+        vvar] (Core.TermMap Maps.empty)) (Core.TypeMap (Core.MapType {+        Core.mapTypeKeys = (Core.TypeVariable kvar),+        Core.mapTypeValues = (Core.TypeVariable vvar)})) Substitution.idTypeSubst keyConstraints)) (Eithers.bind (inferMany fcx3 cx (Lists.map (\k -> (k, "map key")) (Maps.keys m))) (\kRp ->+        let kResults = Pairs.first kRp+            fcx4 = Pairs.second kRp+            kterms = Pairs.first kResults+            ktypes = Pairs.first (Pairs.second kResults)+            ksubst = Pairs.first (Pairs.second (Pairs.second kResults))+            kElemConstraints = Pairs.second (Pairs.second (Pairs.second kResults))+        in (Eithers.bind (inferMany fcx4 (Substitution.substInContext ksubst cx) (Lists.map (\v -> (v, "map value")) (Maps.elems m))) (\vRp ->+          let vResults = Pairs.first vRp+              fcx5 = Pairs.second vRp+              vterms = Pairs.first vResults+              vtypes = Pairs.first (Pairs.second vResults)+              vsubst = Pairs.first (Pairs.second (Pairs.second vResults))+              vElemConstraints = Pairs.second (Pairs.second (Pairs.second vResults))+              kcons =+                      Lists.map (\t -> Typing.TypeConstraint {+                        Typing.typeConstraintLeft = (Core.TypeVariable kvar),+                        Typing.typeConstraintRight = t,+                        Typing.typeConstraintComment = "map key"}) ktypes+              vcons =+                      Lists.map (\t -> Typing.TypeConstraint {+                        Typing.typeConstraintLeft = (Core.TypeVariable vvar),+                        Typing.typeConstraintRight = t,+                        Typing.typeConstraintComment = "map value"}) vtypes+              allMapConstraints = mergeClassConstraints keyConstraints (mergeClassConstraints kElemConstraints vElemConstraints)+          in (Eithers.bind (mapConstraints fcx5 cx (\subst -> yieldWithConstraints fcx5 (Core.TermMap (Maps.fromList (Lists.zip kterms vterms))) (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable kvar),+            Core.mapTypeValues = (Core.TypeVariable vvar)})) (Substitution.composeTypeSubstList [+            ksubst,+            vsubst,+            subst]) (Substitution.substInClassConstraints subst allMapConstraints)) (Lists.concat [+            kcons,+            vcons])) (\mcResult -> Right mcResult)))))))+-- | Infer the type of a Maybe value+inferTypeOfOptional :: Typing.InferenceContext -> Graph.Graph -> Maybe Core.Term -> Either Errors.Error Typing.InferenceResult+inferTypeOfOptional fcx cx m =++      let trmCons = \terms -> Core.TermOptional (Lists.maybeHead terms)+      in (inferTypeOfCollection fcx cx (\x -> Core.TypeOptional x) trmCons "optional element" Sets.empty (Optionals.cases m [] Lists.singleton))+-- | Infer the type of a pair (Either version)+inferTypeOfPair :: Typing.InferenceContext -> Graph.Graph -> (Core.Term, Core.Term) -> Either Errors.Error Typing.InferenceResult+inferTypeOfPair fcx cx p =+    Eithers.bind (inferMany fcx cx [+      (Pairs.first p, "pair first element"),+      (Pairs.second p, "pair second element")]) (\rp ->+      let results = Pairs.first rp+          fcx2 = Pairs.second rp+          iterms = Pairs.first results+          itypes = Pairs.first (Pairs.second results)+          isubst = Pairs.first (Pairs.second (Pairs.second results))+          pairElemConstraints = Pairs.second (Pairs.second (Pairs.second results))+      in (Eithers.bind (atOrFail 0 "inferTypeOfPair ifst" iterms) (\ifst -> Eithers.bind (atOrFail 1 "inferTypeOfPair isnd" iterms) (\isnd -> Eithers.bind (atOrFail 0 "inferTypeOfPair tyFst" itypes) (\tyFst -> Eithers.bind (atOrFail 1 "inferTypeOfPair tySnd" itypes) (\tySnd ->+        let pairTerm = Core.TermPair (ifst, isnd)+            termWithTypes =+                    Core.TermTypeApplication (Core.TypeApplicationTerm {+                      Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {+                        Core.typeApplicationTermBody = pairTerm,+                        Core.typeApplicationTermType = tyFst})),+                      Core.typeApplicationTermType = tySnd})+        in (Right (yieldWithConstraints fcx2 termWithTypes (Core.TypePair (Core.PairType {+          Core.pairTypeFirst = tyFst,+          Core.pairTypeSecond = tySnd})) isubst pairElemConstraints))))))))+-- | Infer the type of a primitive function (Either version)+inferTypeOfPrimitive :: Typing.InferenceContext -> Graph.Graph -> Core.Name -> Either Errors.Error Typing.InferenceResult+inferTypeOfPrimitive fcx cx name =+    Optionals.cases (Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives cx))) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchPrimitive (Errors.NoSuchPrimitiveError {+      Errors.noSuchPrimitiveErrorName = name})))) (\scheme ->+      let tsResult = Resolution.instantiateTypeScheme fcx scheme+          ts = Pairs.first tsResult+          fcx2 = Pairs.second tsResult+          constraints = Optionals.fromOptional Maps.empty (Core.typeSchemeConstraints ts)+      in (Right (yieldCheckedWithConstraints fcx2 (buildTypeApplicationTerm (Core.typeSchemeVariables ts) (Core.TermVariable name)) (Core.typeSchemeBody ts) Substitution.idTypeSubst constraints)))+-- | Infer the type of a record projection (Either version)+inferTypeOfProjection :: Typing.InferenceContext -> Graph.Graph -> Core.Projection -> Either Errors.Error Typing.InferenceResult+inferTypeOfProjection fcx cx proj =++      let tname = Core.projectionTypeName proj+          fname = Core.projectionFieldName proj+      in (Eithers.bind (Resolution.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp ->+        let schemaType = Pairs.first stRp+            fcx2 = Pairs.second stRp+            svars = Core.typeSchemeVariables schemaType+            stype = Core.typeSchemeBody schemaType+        in (Eithers.bind (ExtractCore.recordType tname stype) (\sfields -> Eithers.bind (Resolution.findFieldType fcx2 fname sfields) (\ftyp -> Right (yield fcx2 (buildTypeApplicationTerm svars (Core.TermProject (Core.Projection {+          Core.projectionTypeName = tname,+          Core.projectionFieldName = fname}))) (Core.TypeFunction (Core.FunctionType {+          Core.functionTypeDomain = (Resolution.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)),+          Core.functionTypeCodomain = ftyp})) Substitution.idTypeSubst))))))+-- | Infer the type of a record (Either version)+inferTypeOfRecord :: Typing.InferenceContext -> Graph.Graph -> Core.Record -> Either Errors.Error Typing.InferenceResult+inferTypeOfRecord fcx cx record =++      let tname = Core.recordTypeName record+          fields = Core.recordFields record+          fnames = Lists.map Core.fieldName fields+      in (Eithers.bind (Resolution.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp ->+        let schemaType = Pairs.first stRp+            fcx2 = Pairs.second stRp+        in (Eithers.bind (inferMany fcx2 cx (Lists.map (\f -> (Core.fieldTerm f, (Strings.cat2 "field " (Core.unName (Core.fieldName f))))) fields)) (\rp ->+          let results = Pairs.first rp+              fcx3 = Pairs.second rp+              svars = Core.typeSchemeVariables schemaType+              stype = Core.typeSchemeBody schemaType+              iterms = Pairs.first results+              itypes = Pairs.first (Pairs.second results)+              isubst = Pairs.first (Pairs.second (Pairs.second results))+              recElemConstraints = Pairs.second (Pairs.second (Pairs.second results))+              ityp =+                      Core.TypeRecord (Lists.zipWith (\n -> \t -> Core.FieldType {+                        Core.fieldTypeName = n,+                        Core.fieldTypeType = t}) fnames itypes)+          in (Eithers.bind (mapConstraints fcx3 cx (\subst -> yieldWithConstraints fcx3 (buildTypeApplicationTerm svars (Core.TermRecord (Core.Record {+            Core.recordTypeName = tname,+            Core.recordFields = (Lists.zipWith (\n -> \t -> Core.Field {+              Core.fieldName = n,+              Core.fieldTerm = t}) fnames iterms)}))) (Resolution.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)) (Substitution.composeTypeSubst isubst subst) (Substitution.substInClassConstraints subst recElemConstraints)) [+            Typing.TypeConstraint {+              Typing.typeConstraintLeft = stype,+              Typing.typeConstraintRight = ityp,+              Typing.typeConstraintComment = "schema type of record"}]) (\mcResult -> Right mcResult))))))+-- | Infer the type of a set (Either version)+inferTypeOfSet :: Typing.InferenceContext -> Graph.Graph -> S.Set Core.Term -> Either Errors.Error Typing.InferenceResult+inferTypeOfSet fcx cx s =+    inferTypeOfCollection fcx cx (\x -> Core.TypeSet x) (\terms -> Core.TermSet (Sets.fromList terms)) "set element" (Sets.singleton (Core.Name "ordering")) (Sets.toList s)+-- | Infer the type of a given term (Either version)+inferTypeOfTerm :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> String -> Either Errors.Error Typing.InferenceResult+inferTypeOfTerm fcx cx term desc =++      let fcx2 = fcx+      in case term of+        Core.TermAnnotated v0 -> inferTypeOfAnnotatedTerm fcx2 cx v0+        Core.TermApplication v0 -> inferTypeOfApplication fcx2 cx v0+        Core.TermCases v0 -> inferTypeOfCaseStatement fcx2 cx v0+        Core.TermEither v0 -> inferTypeOfEither fcx2 cx v0+        Core.TermLambda v0 -> inferTypeOfLambda fcx2 cx v0+        Core.TermLet v0 -> inferTypeOfLet fcx2 cx v0+        Core.TermList v0 -> inferTypeOfList fcx2 cx v0+        Core.TermLiteral v0 -> Right (inferTypeOfLiteral fcx2 v0)+        Core.TermMap v0 -> inferTypeOfMap fcx2 cx v0+        Core.TermOptional v0 -> inferTypeOfOptional fcx2 cx v0+        Core.TermPair v0 -> inferTypeOfPair fcx2 cx v0+        Core.TermProject v0 -> inferTypeOfProjection fcx2 cx v0+        Core.TermRecord v0 -> inferTypeOfRecord fcx2 cx v0+        Core.TermSet v0 -> inferTypeOfSet fcx2 cx v0+        Core.TermTypeApplication v0 -> inferTypeOfTypeApplication fcx2 cx v0+        Core.TermTypeLambda v0 -> inferTypeOfTypeLambda fcx2 cx v0+        Core.TermInject v0 -> inferTypeOfInjection fcx2 cx v0+        Core.TermUnit -> Right (inferTypeOfUnit fcx2)+        Core.TermUnwrap v0 -> inferTypeOfUnwrap fcx2 cx v0+        Core.TermVariable v0 -> inferTypeOfVariable fcx2 cx v0+        Core.TermWrap v0 -> inferTypeOfWrappedTerm fcx2 cx v0+-- | Infer the type of a type application (Either version)+inferTypeOfTypeApplication :: Typing.InferenceContext -> Graph.Graph -> Core.TypeApplicationTerm -> Either Errors.Error Typing.InferenceResult+inferTypeOfTypeApplication fcx cx tt =++      let fcxBody = Names.pushSubtermStep Paths.SubtermStepTypeApplicationTerm fcx+      in (Eithers.bind (inferTypeOfTerm fcxBody cx (Core.typeApplicationTermBody tt) "type application term") (\result ->+        let fcx2 = Names.restoreTrace fcx (Typing.inferenceResultContext result)+        in (Right (Typing.InferenceResult {+          Typing.inferenceResultTerm = (Typing.inferenceResultTerm result),+          Typing.inferenceResultType = (Typing.inferenceResultType result),+          Typing.inferenceResultSubst = (Typing.inferenceResultSubst result),+          Typing.inferenceResultClassConstraints = (Typing.inferenceResultClassConstraints result),+          Typing.inferenceResultContext = fcx2}))))+-- | Infer the type of a type abstraction (Either version)+inferTypeOfTypeLambda :: Typing.InferenceContext -> Graph.Graph -> Core.TypeLambda -> Either Errors.Error Typing.InferenceResult+inferTypeOfTypeLambda fcx cx ta =++      let fcxBody = Names.pushSubtermStep Paths.SubtermStepTypeLambdaBody fcx+      in (Eithers.bind (inferTypeOfTerm fcxBody cx (Core.typeLambdaBody ta) "type abstraction") (\result ->+        let fcx2 = Names.restoreTrace fcx (Typing.inferenceResultContext result)+        in (Right (Typing.InferenceResult {+          Typing.inferenceResultTerm = (Typing.inferenceResultTerm result),+          Typing.inferenceResultType = (Typing.inferenceResultType result),+          Typing.inferenceResultSubst = (Typing.inferenceResultSubst result),+          Typing.inferenceResultClassConstraints = (Typing.inferenceResultClassConstraints result),+          Typing.inferenceResultContext = fcx2}))))+-- | The trivial inference rule for the unit term+inferTypeOfUnit :: Typing.InferenceContext -> Typing.InferenceResult+inferTypeOfUnit fcx =+    Typing.InferenceResult {+      Typing.inferenceResultTerm = Core.TermUnit,+      Typing.inferenceResultType = Core.TypeUnit,+      Typing.inferenceResultSubst = Substitution.idTypeSubst,+      Typing.inferenceResultClassConstraints = Maps.empty,+      Typing.inferenceResultContext = fcx}+-- | Infer the type of an unwrap operation (Either version)+inferTypeOfUnwrap :: Typing.InferenceContext -> Graph.Graph -> Core.Name -> Either Errors.Error Typing.InferenceResult+inferTypeOfUnwrap fcx cx tname =+    Eithers.bind (Resolution.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp ->+      let schemaType = Pairs.first stRp+          fcx2 = Pairs.second stRp+          svars = Core.typeSchemeVariables schemaType+          stype = Core.typeSchemeBody schemaType+      in (Eithers.bind (ExtractCore.wrappedType tname stype) (\wtyp -> Right (yield fcx2 (buildTypeApplicationTerm svars (Core.TermUnwrap tname)) (Core.TypeFunction (Core.FunctionType {+        Core.functionTypeDomain = (Resolution.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)),+        Core.functionTypeCodomain = wtyp})) Substitution.idTypeSubst))))+-- | Infer the type of a variable (Either version)+inferTypeOfVariable :: Typing.InferenceContext -> Graph.Graph -> Core.Name -> Either Errors.Error Typing.InferenceResult+inferTypeOfVariable fcx cx name =+    Optionals.cases (Maps.lookup name (Graph.graphBoundTypes cx)) (Optionals.cases (Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives cx))) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+      Errors.noSuchBindingErrorName = name})))) (\scheme ->+      let tsResult = Resolution.instantiateTypeScheme fcx scheme+          ts = Pairs.first tsResult+          fcx2 = Pairs.second tsResult+          constraints = Optionals.fromOptional Maps.empty (Core.typeSchemeConstraints ts)+      in (Right (yieldCheckedWithConstraints fcx2 (buildTypeApplicationTerm (Core.typeSchemeVariables ts) (Core.TermVariable name)) (Core.typeSchemeBody ts) Substitution.idTypeSubst constraints)))) (\scheme ->+      let tsResult = Resolution.instantiateTypeScheme fcx scheme+          ts = Pairs.first tsResult+          fcx2 = Pairs.second tsResult+          constraints = Optionals.fromOptional Maps.empty (Core.typeSchemeConstraints ts)+      in (Right (Typing.InferenceResult {+        Typing.inferenceResultTerm = (buildTypeApplicationTerm (Core.typeSchemeVariables ts) (Core.TermVariable name)),+        Typing.inferenceResultType = (Core.typeSchemeBody ts),+        Typing.inferenceResultSubst = Substitution.idTypeSubst,+        Typing.inferenceResultClassConstraints = constraints,+        Typing.inferenceResultContext = fcx2})))+-- | Infer the type of a wrapped term (Either version)+inferTypeOfWrappedTerm :: Typing.InferenceContext -> Graph.Graph -> Core.WrappedTerm -> Either Errors.Error Typing.InferenceResult+inferTypeOfWrappedTerm fcx cx wt =++      let tname = Core.wrappedTermTypeName wt+          term = Core.wrappedTermBody wt+      in (Eithers.bind (Resolution.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp ->+        let schemaType = Pairs.first stRp+            fcx2 = Pairs.second stRp+            fcxBody = Names.pushSubtermStep Paths.SubtermStepWrappedTerm fcx2+        in (Eithers.bind (inferTypeOfTerm fcxBody cx term "wrapped term") (\result ->+          let fcx3 = Names.restoreTrace fcx2 (Typing.inferenceResultContext result)+              svars = Core.typeSchemeVariables schemaType+              stype = Core.typeSchemeBody schemaType+              iterm = Typing.inferenceResultTerm result+              itype = Typing.inferenceResultType result+              isubst = Typing.inferenceResultSubst result+              ityp = Core.TypeWrap itype+          in (Eithers.bind (mapConstraints fcx3 cx (\subst -> yield fcx3 (buildTypeApplicationTerm svars (Core.TermWrap (Core.WrappedTerm {+            Core.wrappedTermTypeName = tname,+            Core.wrappedTermBody = iterm}))) (Resolution.nominalApplication tname (Lists.map (\x -> Core.TypeVariable x) svars)) (Substitution.composeTypeSubst isubst subst)) [+            Typing.TypeConstraint {+              Typing.typeConstraintLeft = stype,+              Typing.typeConstraintRight = ityp,+              Typing.typeConstraintComment = "schema type of wrapper"}]) (\mcResult -> Right mcResult))))))+-- | Infer types for temporary let bindings (Either version)+inferTypesOfTemporaryBindings :: Typing.InferenceContext -> Graph.Graph -> [Core.Binding] -> Either Errors.Error (+  ([Core.Term], ([Core.Type], (Typing.TypeSubst, (M.Map Core.Name Core.TypeVariableConstraints)))),+  Typing.InferenceContext)+inferTypesOfTemporaryBindings fcx cx bins =++      let emptyResult = Right (([], ([], (Substitution.idTypeSubst, Maps.empty))), fcx)+      in (Optionals.cases (Lists.uncons bins) emptyResult (\binsUc ->+        let binding = Pairs.first binsUc+            tl = Pairs.second binsUc+            k = Core.bindingName binding+            v = Core.bindingTerm binding+            fcxBind = Names.pushSubtermStep (Paths.SubtermStepLetBinding k) fcx+        in (Eithers.bind (inferTypeOfTerm fcxBind cx v (Strings.cat [+          "temporary let binding '",+          (Core.unName k),+          "'"])) (\result1 ->+          let fcx2 = Names.restoreTrace fcx (Typing.inferenceResultContext result1)+              j = Typing.inferenceResultTerm result1+              u_prime = Typing.inferenceResultType result1+              u = Typing.inferenceResultSubst result1+              c1Inferred = Typing.inferenceResultClassConstraints result1+          in (Eithers.bind (Optionals.cases (Core.bindingTypeScheme binding) (Right Maps.empty) (\ts ->+            let tsResult = Resolution.instantiateTypeScheme fcx2 ts+                instantiatedTs = Pairs.first tsResult+                freshConstraints = Optionals.fromOptional Maps.empty (Core.typeSchemeConstraints instantiatedTs)+            in (Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorInference (Errors.InferenceErrorUnification (Errors.UnificationInferenceError {+              Errors.unificationInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx2))),+              Errors.unificationInferenceErrorCause = _e}))) (\_a -> _a) (Unification.unifyTypes fcx2 (Graph.graphSchemaTypes cx) (Core.typeSchemeBody instantiatedTs) u_prime "original binding type")) (\unifySubst -> Right (Substitution.substInClassConstraints unifySubst freshConstraints))))) (\originalBindingConstraints ->+            let c1 = mergeClassConstraints c1Inferred originalBindingConstraints+            in (Eithers.bind (inferTypesOfTemporaryBindings fcx2 (Substitution.substInContext u cx) tl) (\rp2 ->+              let result2 = Pairs.first rp2+                  fcx3 = Pairs.second rp2+                  h = Pairs.first result2+                  r_prime = Pairs.first (Pairs.second result2)+                  restPair = Pairs.second (Pairs.second result2)+                  r = Pairs.first restPair+                  c2 = Pairs.second restPair+                  c1Subst = Substitution.substInClassConstraints r c1+                  mergedConstraints = mergeClassConstraints c1Subst c2+              in (Right (+                (+                  Lists.cons (Substitution.substTypesInTerm r j) h,+                  (Lists.cons (Substitution.substInType r u_prime) r_prime, (Substitution.composeTypeSubst u r, mergedConstraints))),+                fcx3))))))))))+-- | Check if a variable is unbound in context+isUnbound :: Graph.Graph -> Core.Name -> Bool+isUnbound cx v =+    Logic.and (Logic.not (Sets.member v (freeVariablesInContext cx))) (Logic.not (Maps.member v (Graph.graphSchemaTypes cx)))+-- | Map over type constraints after unification+mapConstraints :: Typing.InferenceContext -> Graph.Graph -> (Typing.TypeSubst -> t0) -> [Typing.TypeConstraint] -> Either Errors.Error t0+mapConstraints flowCx cx f constraints =+    Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorInference (Errors.InferenceErrorUnification (Errors.UnificationInferenceError {+      Errors.unificationInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace flowCx))),+      Errors.unificationInferenceErrorCause = _e}))) (\_a -> _a) (Unification.unifyTypeConstraints flowCx (Graph.graphSchemaTypes cx) constraints)) (\s -> Eithers.bind (Checking.checkTypeSubst flowCx cx s) (\_ -> Right (f s)))+-- | Merge two maps of class constraints. When both maps have constraints for the same variable, union the class sets.+mergeClassConstraints :: Ord t0 => (M.Map t0 Core.TypeVariableConstraints -> M.Map t0 Core.TypeVariableConstraints -> M.Map t0 Core.TypeVariableConstraints)+mergeClassConstraints m1 m2 =+    Lists.foldl (\acc -> \pair ->+      let k = Pairs.first pair+          v = Pairs.second pair+      in (Optionals.cases (Maps.lookup k acc) (Maps.insert k v acc) (\existing ->+        let merged =+                Core.TypeVariableConstraints {+                  Core.typeVariableConstraintsClasses = (Lists.nub (Lists.concat2 (Core.typeVariableConstraintsClasses existing) (Core.typeVariableConstraintsClasses v)))}+        in (Maps.insert k merged acc)))) m1 (Maps.toList m2)+-- | Show an inference result for debugging+showInferenceResult :: Typing.InferenceResult -> String+showInferenceResult result =++      let term = Typing.inferenceResultTerm result+          typ = Typing.inferenceResultType result+          subst = Typing.inferenceResultSubst result+      in (Strings.cat [+        "{term=",+        (ShowCore.term term),+        ", type=",+        (ShowCore.type_ typ),+        ", subst=",+        (ShowTyping.typeSubst subst),+        "}"])+-- | Create an inference result with no class constraints+yield :: Typing.InferenceContext -> Core.Term -> Core.Type -> Typing.TypeSubst -> Typing.InferenceResult+yield fcx term typ subst =+    Typing.InferenceResult {+      Typing.inferenceResultTerm = (Substitution.substTypesInTerm subst term),+      Typing.inferenceResultType = (Substitution.substInType subst typ),+      Typing.inferenceResultSubst = subst,+      Typing.inferenceResultClassConstraints = Maps.empty,+      Typing.inferenceResultContext = fcx}+-- | Create a checked inference result+yieldChecked :: Typing.InferenceContext -> Core.Term -> Core.Type -> Typing.TypeSubst -> Typing.InferenceResult+yieldChecked fcx term typ subst =++      let iterm = Substitution.substTypesInTerm subst term+          itype = Substitution.substInType subst typ+      in Typing.InferenceResult {+        Typing.inferenceResultTerm = iterm,+        Typing.inferenceResultType = itype,+        Typing.inferenceResultSubst = subst,+        Typing.inferenceResultClassConstraints = Maps.empty,+        Typing.inferenceResultContext = fcx}+-- | Create a checked inference result with class constraints+yieldCheckedWithConstraints :: Typing.InferenceContext -> Core.Term -> Core.Type -> Typing.TypeSubst -> M.Map Core.Name Core.TypeVariableConstraints -> Typing.InferenceResult+yieldCheckedWithConstraints fcx term typ subst constraints =++      let iterm = Substitution.substTypesInTerm subst term+          itype = Substitution.substInType subst typ+          iconstraints = Substitution.substInClassConstraints subst constraints+      in Typing.InferenceResult {+        Typing.inferenceResultTerm = iterm,+        Typing.inferenceResultType = itype,+        Typing.inferenceResultSubst = subst,+        Typing.inferenceResultClassConstraints = iconstraints,+        Typing.inferenceResultContext = fcx}+-- | Create an inference result with class constraints+yieldWithConstraints :: Typing.InferenceContext -> Core.Term -> Core.Type -> Typing.TypeSubst -> M.Map Core.Name Core.TypeVariableConstraints -> Typing.InferenceResult+yieldWithConstraints fcx term typ subst constraints =+    Typing.InferenceResult {+      Typing.inferenceResultTerm = (Substitution.substTypesInTerm subst term),+      Typing.inferenceResultType = (Substitution.substInType subst typ),+      Typing.inferenceResultSubst = subst,+      Typing.inferenceResultClassConstraints = constraints,+      Typing.inferenceResultContext = fcx}
+ src/main/haskell/Hydra/Json/Bootstrap.hs view
@@ -0,0 +1,3049 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A module which provides a minimal typing environment for decoding other modules from JSON. This avoids certain problems with generating entire source modules into target languages like Java, which is subject to method size limits for large modules like hydra.core.++module Hydra.Json.Bootstrap where+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Paths as Paths+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | A bootstrap typing environment for decoding modules from JSON. Maps each kernel type name to its encoded type, used to seed JSON decoding before the full kernel graph is available.+typesByName :: M.Map Core.Name Core.Type+typesByName =+    M.fromList [+      (+        Core.Name "hydra.coders.Adapter",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType {+            Core.forallTypeParameter = (Core.Name "t1"),+            Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+              Core.forallTypeParameter = (Core.Name "t2"),+              Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+                Core.forallTypeParameter = (Core.Name "v1"),+                Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+                  Core.forallTypeParameter = (Core.Name "v2"),+                  Core.forallTypeBody = (Core.TypeRecord [+                    Core.FieldType {+                      Core.fieldTypeName = (Core.Name "isLossy"),+                      Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                        Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBoolean),+                        Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                          (+                            Core.TermVariable (Core.Name "description"),+                            (Core.TermLiteral (Core.LiteralString "Whether information may be lost in the course of this adaptation")))]))}))},+                    Core.FieldType {+                      Core.fieldTypeName = (Core.Name "source"),+                      Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                        Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "t1")),+                        Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                          (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The source type")))]))}))},+                    Core.FieldType {+                      Core.fieldTypeName = (Core.Name "target"),+                      Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                        Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "t2")),+                        Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                          (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The target type")))]))}))},+                    Core.FieldType {+                      Core.fieldTypeName = (Core.Name "coder"),+                      Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                        Core.annotatedTypeBody = (Core.TypeApplication (Core.ApplicationType {+                          Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                            Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.coders.Coder")),+                            Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v1"))})),+                          Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v2"))})),+                        Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                          (+                            Core.TermVariable (Core.Name "description"),+                            (Core.TermLiteral (Core.LiteralString "The coder for transforming instances of the source type to instances of the target type")))]))}))}])}))}))}))})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A two-level bidirectional encoder which adapts types to types and terms to terms")))]))}))),+      (+        Core.Name "hydra.coders.AdapterContext",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "graph"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The underlying graph of elements and primitives")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "language"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.coders.Language")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The language being encoded or decoded")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "adapters"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                      Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                        Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                          Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.coders.Adapter")),+                          Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Type"))})),+                        Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Type"))})),+                      Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                    Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A map of type names to adapters for those types")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An evaluation context together with a source language and a target language")))]))}))),+      (+        Core.Name "hydra.coders.Bicoder",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType {+            Core.forallTypeParameter = (Core.Name "t1"),+            Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+              Core.forallTypeParameter = (Core.Name "t2"),+              Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+                Core.forallTypeParameter = (Core.Name "v1"),+                Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+                  Core.forallTypeParameter = (Core.Name "v2"),+                  Core.forallTypeBody = (Core.TypeRecord [+                    Core.FieldType {+                      Core.fieldTypeName = (Core.Name "encode"),+                      Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                        Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                          Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t1")),+                          Core.functionTypeCodomain = (Core.TypeApplication (Core.ApplicationType {+                            Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                              Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                                Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.coders.Adapter")),+                                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))})),+                                Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t2"))})),+                              Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v1"))})),+                            Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v2"))}))})),+                        Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                          (+                            Core.TermVariable (Core.Name "description"),+                            (Core.TermLiteral (Core.LiteralString "A function from source types to adapters")))]))}))},+                    Core.FieldType {+                      Core.fieldTypeName = (Core.Name "decode"),+                      Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                        Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                          Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t2")),+                          Core.functionTypeCodomain = (Core.TypeApplication (Core.ApplicationType {+                            Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                              Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                                Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.coders.Adapter")),+                                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t2"))})),+                                Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t1"))})),+                              Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v2"))})),+                            Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v1"))}))})),+                        Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                          (+                            Core.TermVariable (Core.Name "description"),+                            (Core.TermLiteral (Core.LiteralString "A function from target types to adapters")))]))}))}])}))}))}))})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A two-level encoder and decoder, operating both at a type level and an instance (data) level")))]))}))),+      (+        Core.Name "hydra.coders.CaseConventions",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "constant"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for compile-time constant names")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "directory"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for each directory level in the emitted source tree")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "enumValue"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for enum-variant value names")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "field"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Convention for record field names")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "file"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for the source-file basename")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "module"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for a single segment of a module name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "term"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for top-level term definitions (functions, module-level values)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "termVariable"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for locally-bound term names (lambda parameters, let-bindings)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Convention for type names")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeVariable"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Convention for type-level variable names")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Per-target case conventions for name forms that vary across emission targets")))]))}))),+      (+        Core.Name "hydra.coders.Coder",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType {+            Core.forallTypeParameter = (Core.Name "v1"),+            Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+              Core.forallTypeParameter = (Core.Name "v2"),+              Core.forallTypeBody = (Core.TypeRecord [+                Core.FieldType {+                  Core.fieldTypeName = (Core.Name "encode"),+                  Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                    Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                      Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")),+                      Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                        Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v1")),+                        Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                          Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.Error")),+                          Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v2"))}))}))})),+                    Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                      (+                        Core.TermVariable (Core.Name "description"),+                        (Core.TermLiteral (Core.LiteralString "A function which encodes source values as target values, given an InferenceContext for fresh-variable state and subterm-path tracing")))]))}))},+                Core.FieldType {+                  Core.fieldTypeName = (Core.Name "decode"),+                  Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                    Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                      Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")),+                      Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                        Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v2")),+                        Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                          Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.Error")),+                          Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v1"))}))}))})),+                    Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                      (+                        Core.TermVariable (Core.Name "description"),+                        (Core.TermLiteral (Core.LiteralString "A function which decodes target values as source values, given an InferenceContext for fresh-variable state and subterm-path tracing")))]))}))}])}))})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An encoder and decoder; a bidirectional transformation between two types")))]))}))),+      (+        Core.Name "hydra.coders.CoderDirection",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "encode"),+              Core.fieldTypeType = Core.TypeUnit},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "decode"),+              Core.fieldTypeType = Core.TypeUnit}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Indicates either the 'out' or the 'in' direction of a coder")))]))}))),+      (+        Core.Name "hydra.coders.Language",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.coders.LanguageName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The unique name of the language")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "constraints"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.coders.LanguageConstraints")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Constraints which characterize the language's type and term grammars")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "supportedFeatures"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.coders.LanguageFeature"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Target-language or target-runtime capabilities the emitter may assume are available")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "caseConventions"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.coders.CaseConventions")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Per-target case conventions for the various kinds of identifiers emitted by the coder")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "defaultFileExtension"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.util.FileExtension")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Conventional file extension for emitted source files, without the leading dot (e.g. \"scala\", \"py\")")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A named language together with its grammar constraints, capability profile, naming conventions, and conventional file extension")))]))}))),+      (+        Core.Name "hydra.coders.LanguageConstraints",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "literalVariants"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.LiteralVariant"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "All supported literal variants")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "floatTypes"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.FloatType"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "All supported float types")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "integerTypes"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.IntegerType"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "All supported integer types")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "termVariants"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.TermVariant"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "All supported term variants")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeVariants"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.variants.TypeVariant"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "All supported type variants")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "types"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                  Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A logical set of types, as a predicate which tests a type for inclusion")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A set of constraints on valid type and term expressions, characterizing a language")))]))}))),+      (+        Core.Name "hydra.coders.LanguageFeature",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "partialApplication"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The target runtime can invoke an n-ary function with fewer than n arguments without error. When absent, the emitter eta-expands partially-applied terms.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "nestedCaseStatements"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The target runtime can handle deeply nested case statements without stack issues. When absent, the emitter hoists cases out into top-level helpers.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "nestedPolymorphicLetBindings"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The target language permits polymorphic let-bindings in expression position. When absent, the emitter hoists polymorphic lets to top level.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A target-language or target-runtime capability the coder may rely on. Absence from a Language's supportedFeatures set means the emitter must work around the missing capability.")))]))}))),+      (+        Core.Name "hydra.coders.LanguageName",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The unique name of a language")))]))}))),+      (+        Core.Name "hydra.coders.SymmetricAdapter",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType {+            Core.forallTypeParameter = (Core.Name "t"),+            Core.forallTypeBody = (Core.TypeForall (Core.ForallType {+              Core.forallTypeParameter = (Core.Name "v"),+              Core.forallTypeBody = (Core.TypeApplication (Core.ApplicationType {+                Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                      Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.coders.Adapter")),+                      Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})),+                    Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})),+                Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A bidirectional encoder which maps between the same type and term languages on either side")))]))}))),+      (+        Core.Name "hydra.coders.TraversalOrder",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "pre"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Pre-order traversal")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "post"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Post-order traversal")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Specifies either a pre-order or post-order traversal")))]))}))),+      (+        Core.Name "hydra.coders.TypeAdapter",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+            Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.coders.AdapterContext")),+            Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Type")),+              Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeLiteral Core.LiteralTypeString),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.coders.SymmetricAdapter")),+                    Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Type"))})),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))}))})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A function which maps a Hydra type to a symmetric adapter between types and terms")))]))}))),+      (+        Core.Name "hydra.core.AnnotatedTerm",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The term being annotated")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "annotation"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The annotation as a single term. By convention this is a map term (Name -> Term) so that multiple independent annotations can coexist, but applications are free to use any term shape.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A term together with an annotation")))]))}))),+      (+        Core.Name "hydra.core.AnnotatedType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type being annotated")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "annotation"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The annotation as a single term. By convention this is a map term (Name -> Term) so that multiple independent annotations can coexist, but applications are free to use any term shape.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A type together with an annotation")))]))}))),+      (+        Core.Name "hydra.core.Application",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "function"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The left-hand side of the application")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "argument"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The right-hand side of the application")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A term which applies a function to an argument")))]))}))),+      (+        Core.Name "hydra.core.ApplicationType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "function"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The left-hand side of the application")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "argument"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The right-hand side of the application")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "The type-level analog of an application term")))]))}))),+      (+        Core.Name "hydra.core.Binding",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the bound variable")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "term"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The term to which the variable is bound")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeScheme"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The optional type scheme of the bound term")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A field with an optional type scheme, used to bind variables to terms in a 'let' expression")))]))}))),+      (+        Core.Name "hydra.core.CaseAlternative",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The name of the union variant matched by this alternative")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "handler"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The handler applied to the matched variant's payload")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A single alternative of a case statement (union elimination): the variant being matched, together with the term that handles it.")))]))}))),+      (+        Core.Name "hydra.core.CaseStatement",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the union type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "default"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.core.Term"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An optional default case, used if none of the explicit cases match")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "cases"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.CaseAlternative"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A list of case alternatives, one per union variant being handled")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A union elimination; a case statement")))]))}))),+      (+        Core.Name "hydra.core.EitherType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "left"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The 'left' alternative")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "right"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The 'right' alternative")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type which provides a choice between a 'left' type and a 'right' type")))]))}))),+      (+        Core.Name "hydra.core.Field",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the field")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "term"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The value of the field")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A name/term pair")))]))}))),+      (+        Core.Name "hydra.core.FieldType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the field")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of the field")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A name/type pair")))]))}))),+      (+        Core.Name "hydra.core.FloatType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "float32"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 32-bit floating-point type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "float64"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 64-bit floating-point type")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A floating-point type")))]))}))),+      (+        Core.Name "hydra.core.FloatValue",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "float32"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 32-bit floating-point value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "float64"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 64-bit floating-point value")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A floating-point literal value")))]))}))),+      (+        Core.Name "hydra.core.ForallType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "parameter"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The variable which is bound by the lambda")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The body of the lambda")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A universally quantified type; the System F equivalent of a type scheme, and the type-level equivalent of a lambda term.")))]))}))),+      (+        Core.Name "hydra.core.FunctionType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "domain"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The domain (input) type of the function")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "codomain"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The codomain (output) type of the function")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A function type, also known as an arrow type")))]))}))),+      (+        Core.Name "hydra.core.Injection",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the union type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "field"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Field")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The field being injected, including its name and value")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An instance of a union type; i.e. a string-indexed generalization of inl() or inr()")))]))}))),+      (+        Core.Name "hydra.core.IntegerType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "bigint"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An arbitrary-precision integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int8"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An 8-bit signed integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int16"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 16-bit signed integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int32"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 32-bit signed integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int64"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 64-bit signed integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint8"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An 8-bit unsigned integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint16"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 16-bit unsigned integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint32"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 32-bit unsigned integer type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint64"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 64-bit unsigned integer type")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An integer type")))]))}))),+      (+        Core.Name "hydra.core.IntegerValue",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "bigint"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An arbitrary-precision integer value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int8"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt8)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An 8-bit signed integer value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int16"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt16)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A 16-bit signed integer value (short value)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int32"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A 32-bit signed integer value (int value)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "int64"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt64)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A 64-bit signed integer value (long value)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint8"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint8)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An 8-bit unsigned integer value (byte)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint16"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint16)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A 16-bit unsigned integer value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint32"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint32)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A 32-bit unsigned integer value (unsigned int)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "uint64"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint64)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A 64-bit unsigned integer value (unsigned long)")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An integer literal value")))]))}))),+      (+        Core.Name "hydra.core.Lambda",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "parameter"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The parameter of the lambda")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "domain"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.core.Type"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An optional domain type for the lambda")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The body of the lambda")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A function abstraction (lambda)")))]))}))),+      (+        Core.Name "hydra.core.Let",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "bindings"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Binding"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The list of variable bindings")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The body term in which the variables are bound")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A set of (possibly recursive) 'let' bindings together with a body in which they are bound")))]))}))),+      (+        Core.Name "hydra.core.Literal",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "binary"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBinary),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A binary literal")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "boolean"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBoolean),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A boolean literal")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "decimal"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeDecimal),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An arbitrary-precision decimal literal")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "float"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.FloatValue")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A floating-point literal")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "integer"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.IntegerValue")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An integer literal")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "string"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A string literal")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A term constant; an instance of a literal type")))]))}))),+      (+        Core.Name "hydra.core.LiteralType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "binary"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The type of a binary (byte string) value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "boolean"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The type of a boolean (true/false) value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "decimal"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The type of an arbitrary-precision decimal value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "float"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.FloatType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of a floating-point value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "integer"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.IntegerType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of an integer value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "string"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of a string value")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Any of a fixed set of literal types, also called atomic types, base types, primitive types, or type constants")))]))}))),+      (+        Core.Name "hydra.core.MapType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "keys"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of keys in the map")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "values"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of values in the map")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A map type")))]))}))),+      (+        Core.Name "hydra.core.Name",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A unique identifier in some context; a string-valued key")))]))}))),+      (+        Core.Name "hydra.core.PairType",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "first"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The first component of the pair")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "second"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The second component of the pair")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type which pairs a 'first' type and a 'second' type")))]))}))),+      (+        Core.Name "hydra.core.Projection",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the record type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "fieldName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the projected field")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A record elimination; a projection")))]))}))),+      (+        Core.Name "hydra.core.Record",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the record type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "fields"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Field"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The fields of the record, as a list of name/term pairs")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A record, or labeled tuple; a map of field names to terms")))]))}))),+      (+        Core.Name "hydra.core.Term",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "annotated"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedTerm")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A term annotated with metadata")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "application"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Application")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A function application")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "cases"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.CaseStatement")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A union elimination; a case statement")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "either"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeEither (Core.EitherType {+                  Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                  Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An either value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "inject"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Injection")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An injection; an instance of a union type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "lambda"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Lambda")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A function abstraction (lambda)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "let"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Let")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A 'let' term, which binds variables to terms")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "list"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Term"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A list")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "literal"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Literal")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A literal value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "map"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A map of keys to values")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "optional"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.core.Term"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An optional value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "pair"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypePair (Core.PairType {+                  Core.pairTypeFirst = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                  Core.pairTypeSecond = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A pair (2-tuple)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "project"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Projection")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A record elimination; a projection")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "record"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Record")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A record term")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "set"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.Term"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A set of values")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeApplication"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeApplicationTerm")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A System F type application term")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeLambda"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeLambda")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A System F type abstraction term")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unit"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A unit value; a term with no value")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unwrap"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An unwrap elimination; the inverse of a wrap. Given the name of a wrapper type, unwraps an instance of that type to its underlying body value.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "variable"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A variable reference")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "wrap"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A wrapped term; an instance of a wrapper type (newtype)")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A data term")))]))}))),+      (+        Core.Name "hydra.core.Type",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "annotated"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An annotated type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "application"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.ApplicationType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A type application")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "either"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.EitherType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An either (sum) type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "forall"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.ForallType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A universally quantified (polymorphic) type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "function"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.FunctionType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A function type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "list"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A list type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "literal"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.LiteralType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A literal type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "map"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.MapType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A map type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "optional"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An optional type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "pair"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.PairType")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A pair (2-tuple) type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "record"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.FieldType"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A record type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "set"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A set type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "union"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.FieldType"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A union type with field names")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unit"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The unit type \8212 the nullary conjunction; one inhabitant. Dual to `void`.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "variable"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A type variable")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "void"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The void (uninhabited, or bottom) type \8212 the nullary disjunction; zero inhabitants. Dual to `unit`.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "wrap"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A wrapped type (newtype). There is no corresponding `unwrap` variant at the type level: wrap is the introduction form, and a wrapper type's underlying body type is given by the `wrap` variant's argument.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A data type")))]))}))),+      (+        Core.Name "hydra.core.TypeApplicationTerm",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The term being applied to a type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type argument")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A term applied to a type; a type application.")))]))}))),+      (+        Core.Name "hydra.core.TypeClassConstraint",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "simple"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A simple type class constraint, naming a single type class")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type class constraint on a type variable. Currently has only one variant, but designed to be forward-compatible with multi-parameter type classes and constraints on type expressions.")))]))}))),+      (+        Core.Name "hydra.core.TypeLambda",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "parameter"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The type variable introduced by the abstraction")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The body of the abstraction")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A System F type abstraction term")))]))}))),+      (+        Core.Name "hydra.core.TypeScheme",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "variables"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Name"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The free type variables")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type expression")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "constraints"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableConstraints"))}))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Optional constraints on type variables, including typeclass constraints. The map keys are type variable names.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type expression together with free type variables occurring in the expression")))]))}))),+      (+        Core.Name "hydra.core.TypeVariableConstraints",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "classes"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.TypeClassConstraint"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The typeclass constraints on this type variable")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Constraints associated with a type variable, including typeclass constraints")))]))}))),+      (+        Core.Name "hydra.core.WrappedTerm",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the wrapper type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The wrapped term")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A term wrapped in a type name")))]))}))),+      (+        Core.Name "hydra.errors.DecodingError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An error that occurred during decoding of a term")))]))}))),+      (+        Core.Name "hydra.errors.EmptyListError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = Core.TypeUnit,+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An empty list was encountered where a non-empty list was required")))]))}))),+      (+        Core.Name "hydra.errors.Error",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "checking"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A type checking error")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "decoding"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An error that occurred during decoding of a term")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "duplicateBinding"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateBindingError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A duplicate binding name error")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "duplicateField"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateFieldError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A duplicate field name error")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "extraction"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.ExtractionError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An error that occurred while extracting a value from a term")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "inference"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.InferenceError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A type inference error")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "invalidLiteral"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLiteralError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A literal value validation error")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "other"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.OtherError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Any other error")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "resolution"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.ResolutionError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A name-resolution error")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "undefinedField"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedFieldError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A reference to an undefined field")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "undefinedTermVariable"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTermVariableError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A reference to an undefined term variable")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "untypedTermVariable"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UntypedTermVariableError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A term variable whose type is not known")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unexpectedTermVariant"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTermVariantError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An unexpected term variant")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unexpectedTypeVariant"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTypeVariantError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "An unexpected type variant")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unification"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A type unification error")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An error of any kind, with kernel errors particularly differentiated")))]))}))),+      (+        Core.Name "hydra.errors.ExtractionError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "emptyList"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.EmptyListError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An empty list was encountered where a non-empty list was required")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "multipleBindings"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.MultipleBindingsError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Multiple let bindings were found with the same name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "multipleFields"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.MultipleFieldsError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Multiple record fields were found with the same field name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "noMatchingField"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.NoMatchingFieldError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "No field with the expected name was found in a record")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "noSuchBinding"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchBindingError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "No let binding with the expected name was found")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "notEnoughCases"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.NotEnoughCasesError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A case statement did not contain enough cases to match the target")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unexpectedShape"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.UnexpectedShapeError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A term, type, literal, or other value had an unexpected shape")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An error that occurred while extracting a typed value from a term")))]))}))),+      (+        Core.Name "hydra.errors.InferenceError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "checking"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A type checking error encountered during inference")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "other"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.OtherInferenceError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A generic inference error carrying a message and a subterm path. Placeholder arm; sites should migrate to typed variants.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unification"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.UnificationInferenceError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A unification failure encountered while inferring types")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An error that occurred during type inference")))]))}))),+      (+        Core.Name "hydra.errors.MultipleBindingsError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The binding name which was duplicated")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Multiple let bindings with the same name were found")))]))}))),+      (+        Core.Name "hydra.errors.MultipleFieldsError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "fieldName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The field name which appeared more than once")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Multiple fields with the same name were found in a record")))]))}))),+      (+        Core.Name "hydra.errors.NoMatchingFieldError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "fieldName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The field name which was not found")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "No field with the expected name was present")))]))}))),+      (+        Core.Name "hydra.errors.NoSuchBindingError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The binding name which was not found")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "No let binding with the expected name was present")))]))}))),+      (+        Core.Name "hydra.errors.NoSuchPrimitiveError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The primitive name which was not found")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "No primitive function with the expected name was registered in the graph")))]))}))),+      (+        Core.Name "hydra.errors.NotEnoughCasesError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = Core.TypeUnit,+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A case statement was missing a case for the requested variant")))]))}))),+      (+        Core.Name "hydra.errors.OtherError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Any other error")))]))}))),+      (+        Core.Name "hydra.errors.OtherInferenceError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "path"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.paths.SubtermPath")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The subterm path at which the error was observed")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "message"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A human-readable error message")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A generic inference error: message + subterm path")))]))}))),+      (+        Core.Name "hydra.errors.OtherResolutionError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A generic resolution error: message")))]))}))),+      (+        Core.Name "hydra.errors.ResolutionError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "noSuchBinding"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchBindingError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "No binding with the expected name was found in the graph")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "noSuchPrimitive"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchPrimitiveError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "No primitive function with the expected name was found in the graph")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "noMatchingField"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.NoMatchingFieldError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "No field with the expected name was present in a record or case statement")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "other"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.OtherResolutionError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A generic resolution error carrying a message")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "unexpectedShape"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.UnexpectedShapeError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A term had a shape other than the one expected (e.g. a record, an injection)")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An error that occurred while resolving a name, primitive, or record/union shape in a graph")))]))}))),+      (+        Core.Name "hydra.errors.UnexpectedShapeError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "expected"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A description of the expected shape")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "actual"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A description of the shape actually encountered")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A term, type, literal, or related value had a shape other than the one expected")))]))}))),+      (+        Core.Name "hydra.errors.UnificationError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "leftType"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The left-hand type in the unification")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "rightType"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The right-hand type in the unification")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "message"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A human-readable error message")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An error that occurred during type unification")))]))}))),+      (+        Core.Name "hydra.errors.UnificationInferenceError",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "path"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.paths.SubtermPath")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The subterm path at which the unification failure was observed")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "cause"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The underlying unification error")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A unification failure at a specific subterm locus during inference")))]))}))),+      (+        Core.Name "hydra.graph.Graph",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "boundTerms"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The terms bound by all term variables in scope")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "boundTypes"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The type schemes of all term variables in scope")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "classConstraints"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableConstraints"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A mutable map from type variable names to their accumulated class constraints. This is populated during type inference when operations requiring Eq or Ord are encountered.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "lambdaVariables"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.Name"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The set of term variables introduced by specifically by lambdas")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "metadata"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Any additional metadata bound to term variables in scope")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "primitives"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.graph.Primitive"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "All primitive functions and constants by name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "schemaTypes"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "All schema types (type schemes) in scope")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeVariables"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeSet (Core.TypeVariable (Core.Name "hydra.core.Name"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The set of type variables introduced specifically by type lambdas")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A graph, or lexical environment which binds names to terms, types, primitives, and metadata")))]))}))),+      (+        Core.Name "hydra.graph.Library",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A common prefix for all primitive function names in the library")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "prefix"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A preferred namespace prefix for function names in the library")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "primitives"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.graph.Primitive"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The primitives defined in this library")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A library of primitive functions")))]))}))),+      (+        Core.Name "hydra.graph.Primitive",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "definition"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.PrimitiveDefinition")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The host-independent declarative metadata for the primitive: name, description, signature, totality and purity flags, and an optional reference implementation.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "implementation"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                    Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                      Core.functionTypeDomain = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Term"))),+                      Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                        Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.Error")),+                        Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))}))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A concrete, host-specific implementation of the primitive function: a mapping from a list of argument terms to a result term, or an error. Arguments are reduced and stripped of annotations by the interpreter before the implementation is invoked, so the implementation can pattern-match the argument terms directly; a higher-order primitive can return an unreduced applicative term and let the outer reducer fold it. The current carrier still threads `InferenceContext` and `Graph` for historical encode/decode and reducer-callback plumbing; no primitive's compute logic uses them, and they are slated for removal (https://github.com/CategoricalData/hydra/issues/446), sequenced with the `defaultImplementation` integration tracked in https://github.com/CategoricalData/hydra/issues/437.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A built-in function or constant, consisting of the host-independent PrimitiveDefinition (name, signature, metadata) plus a host-specific implementation.")))]))}))),+      (+        Core.Name "hydra.graph.TermCoder",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType {+            Core.forallTypeParameter = (Core.Name "a"),+            Core.forallTypeBody = (Core.TypeRecord [+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "type"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The Hydra type of encoded terms")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "encode"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")),+                    Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                      Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                      Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                        Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                        Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                          Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.Error")),+                          Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))}))})),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (+                      Core.TermVariable (Core.Name "description"),+                      (Core.TermLiteral (Core.LiteralString "An encode function from terms to native values")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "decode"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")),+                    Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                      Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),+                      Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                        Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.Error")),+                        Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}))})),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (+                      Core.TermVariable (Core.Name "description"),+                      (Core.TermLiteral (Core.LiteralString "A decode function from native values to terms")))]))}))}])})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type together with a coder for mapping terms into arguments for primitive functions, and mapping computed results into terms.")))]))}))),+      (+        Core.Name "hydra.packaging.Definition",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "term"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.TermDefinition")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A term definition")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.TypeDefinition")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A type definition")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "primitive"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.PrimitiveDefinition")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A primitive definition")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A definition, which may be either a term, type, or primitive definition")))]))}))),+      (+        Core.Name "hydra.packaging.DefinitionReference",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A reference to a type definition, by name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "term"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A reference to a term definition, by name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "primitive"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A reference to a primitive definition, by name")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A typed reference to a definition: a type, a term, or a primitive, identified by name")))]))}))),+      (+        Core.Name "hydra.packaging.EntityMetadata",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "description"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeString)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An optional, concise one-line human-readable summary of the entity.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "comments"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Zero or more long-form prose paragraphs: cross-cutting semantic conventions, caveats, and references that would otherwise be repeated across the entity's constituents.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "seeAlso"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.packaging.EntityReference"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Typed cross-references to related entities, for navigation and documentation.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "lifecycle"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.LifecycleInfo"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Optional version-lifecycle milestones for the entity.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Documentation and lifecycle metadata attachable to a packaging entity (package, module, or definition). Bundling these fields in one type lets future metadata be added without changing the field shape of the entities that carry it.")))]))}))),+      (+        Core.Name "hydra.packaging.EntityReference",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "package"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.PackageName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A reference to a package, by name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "module"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A reference to a module, by name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "definition"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.DefinitionReference")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A reference to a definition (type, term, or primitive)")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A typed reference to a packaging entity: a package, a module, or a definition")))]))}))),+      (+        Core.Name "hydra.packaging.LifecycleInfo",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "availableSince"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.Version"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The version in which the entity was introduced, if known.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "deprecatedSince"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.Version"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The version in which the entity was deprecated, if applicable.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Version-lifecycle milestones for a packaging entity. Each milestone is independently optional; further milestones (e.g. stableSince, removedSince) may be added without changing dependent types.")))]))}))),+      (+        Core.Name "hydra.packaging.Module",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The name of the module, which is also the common prefix for all element names in the module")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "metadata"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Optional documentation and lifecycle metadata for the module")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "dependencies"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.packaging.ModuleDependency"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Any modules which this module directly depends on")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "definitions"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.packaging.Definition"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The definitions in this module")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A logical collection of elements sharing a common module name, having dependencies on zero or more other modules")))]))}))),+      (+        Core.Name "hydra.packaging.ModuleDependency",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "module"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the depended-on module")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "package"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.PackageName"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The package providing the depended-on module, if disambiguation is required")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A dependency on another module, identified by its name and (optionally) the package which provides it. When the package is omitted, the resolver searches all packages in scope; a duplicate module name across packages is a resolution error which can be disambiguated by naming the intended package explicitly.")))]))}))),+      (+        Core.Name "hydra.packaging.ModuleName",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "The unique name of a module; a prefix for the names of elements defined in the module.")))]))}))),+      (+        Core.Name "hydra.packaging.Package",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.PackageName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the package")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "metadata"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Optional documentation and lifecycle metadata for the package")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "dependencies"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.packaging.PackageDependency"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The packages which this package depends on")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "modules"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.packaging.Module"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The modules in this package")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A package, which is a named collection of modules with metadata and dependencies")))]))}))),+      (+        Core.Name "hydra.packaging.PackageDependency",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.PackageName")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the depended-on package")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "version"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.packaging.VersionSpecifier")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The version-range constraint on the depended-on package")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A dependency on another package, identified by name and constrained by an optional version specifier")))]))}))),+      (+        Core.Name "hydra.packaging.PackageName",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "The unique name of a package, e.g. \"hydra-kernel\" or \"hydra-python\"")))]))}))),+      (+        Core.Name "hydra.packaging.PrimitiveDefinition",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the primitive")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "metadata"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Optional documentation and lifecycle metadata for the primitive.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "signature"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.typing.TermSignature")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The signature of the primitive. Always explicit, never inferred.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "isPure"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBoolean),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Whether the primitive is pure (referentially transparent, no observable side effects). Normally true.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "isTotal"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBoolean),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Whether the primitive is total (terminates on every input of its declared type). Normally true.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "defaultImplementation"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.core.Term"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An optional cross-compilable reference implementation of the primitive, expressed as a Hydra term. Used by interpreters lacking a native implementation and as a proof-friendly reference. Distinct from the per-host Primitive.implementation.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A primitive definition: the universal, host-independent declarative metadata for a primitive, including name, signature, documentation and lifecycle metadata, totality and purity flags, and an optional default implementation expressed as a Hydra term.")))]))}))),+      (+        Core.Name "hydra.packaging.TermDefinition",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the term")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "metadata"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Optional documentation and lifecycle metadata for the term definition")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "signature"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.typing.TermSignature"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The optional signature of the term. When absent, the signature has yet to be inferred.")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The term being defined")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A term-level definition, including a name, an optional signature, and a term")))]))}))),+      (+        Core.Name "hydra.packaging.TypeDefinition",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the type")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "metadata"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Optional documentation and lifecycle metadata for the type definition")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "body"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type scheme being defined")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type-level definition, including a name and the type scheme")))]))}))),+      (+        Core.Name "hydra.packaging.Version",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A version string, e.g. \"0.15\" or \"1.0.0\".")))]))}))),+      (+        Core.Name "hydra.packaging.VersionSpecifier",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "any"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Any version satisfies the dependency")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A specifier constraining acceptable versions of a dependency. Currently only the `any` (unit) specifier is defined; future variants such as `exact`, `caret`, and `range` may be added without breaking consumers of the `any` form.")))]))}))),+      (+        Core.Name "hydra.typing.FunctionStructure",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType {+            Core.forallTypeParameter = (Core.Name "env"),+            Core.forallTypeBody = (Core.TypeRecord [+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "typeParams"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Name"))),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Type parameters (from type lambdas)")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "params"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Name"))),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Value parameters (from lambdas)")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "bindings"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Binding"))),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (+                      Core.TermVariable (Core.Name "description"),+                      (Core.TermLiteral (Core.LiteralString "Let bindings accumulated from the term")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "body"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (+                      Core.TermVariable (Core.Name "description"),+                      (Core.TermLiteral (Core.LiteralString "The body term after removing all lambdas, lets, etc.")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "domains"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.Type"))),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Domain types of the value parameters")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "codomain"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.core.Type"))),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (+                      Core.TermVariable (Core.Name "description"),+                      (Core.TermLiteral (Core.LiteralString "The return type of the function (if type inference succeeded)")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "environment"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "env")),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (+                      Core.TermVariable (Core.Name "description"),+                      (Core.TermLiteral (Core.LiteralString "Updated environment after processing all bindings")))]))}))}])})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A structured representation of a function term's components, replacing ad-hoc tuples. This captures all the information extracted from peeling lambdas, type lambdas, lets, and type applications from a term.")))]))}))),+      (+        Core.Name "hydra.typing.InferenceContext",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "freshTypeVariableCount"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Counter used to generate distinct fresh type variables during inference")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "trace"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.paths.SubtermStep"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The current subterm-path trace, accumulated backwards (head = most-recently-pushed step, corresponding to the deepest point in the descent). At the moment an inference error is constructed, the list is reversed and wrapped into a SubtermPath (root-to-leaf order) and stamped onto the error.")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "State threaded through type inference: the fresh type variable counter and the current subterm-path trace.")))]))}))),+      (+        Core.Name "hydra.typing.InferenceResult",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "term"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The term which was inferred")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The inferred type of the term")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "subst"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.typing.TypeSubst")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The type substitution resulting from unification")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "classConstraints"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                  Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableConstraints"))})),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Class constraints discovered during inference (e.g., Ord constraints from Map.lookup)")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "context"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The updated InferenceContext after inference (carries fresh-variable counter and trace)")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "The result of applying inference rules to a term.")))]))}))),+      (+        Core.Name "hydra.typing.Parameter",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the parameter")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "description"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeString)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An optional human-readable description of the parameter")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of the parameter")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "isLazy"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeBoolean),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Whether the parameter must be passed lazily (thunked) at call sites in hosts that distinguish strict from lazy evaluation")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A named, typed parameter of a term, with optional human-readable description and a flag indicating whether the parameter requires lazy evaluation by hosts which support it.")))]))}))),+      (+        Core.Name "hydra.typing.Result",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "description"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeString)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "An optional human-readable description of the result")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "type"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The type of the result")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "The result of a term, consisting of a type and an optional human-readable description.")))]))}))),+      (+        Core.Name "hydra.typing.TermSignature",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "typeParameters"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.typing.TypeParameter"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The type parameters of the term, in order")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "parameters"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.typing.Parameter"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "The value parameters of the term, in order")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "result"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.typing.Result")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The result of the term")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A structured signature for a term: an ordered list of type parameters (with optional class constraints), an ordered list of value parameters, and a result. TermSignature is a richer view of TypeScheme: every TermSignature can be converted to a TypeScheme by erasing parameter names, descriptions, and laziness flags.")))]))}))),+      (+        Core.Name "hydra.typing.TermSubst",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A substitution of term variables for terms")))]))}))),+      (+        Core.Name "hydra.typing.TypeClass",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "description"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A human-readable description of the type class")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type class identifier together with a human-readable description. Type classes are referenced as bare names (e.g. the local name \"equality\") in TypeVariableConstraints.classes; the canonical definitions live as term bindings under hydra.classes.")))]))}))),+      (+        Core.Name "hydra.typing.TypeConstraint",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "left"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The left-hand side of the constraint")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "right"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The right-hand side of the constraint")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "comment"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "A description of the type constraint which may be used for tracing or debugging")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An assertion that two types can be unified into a single type")))]))}))),+      (+        Core.Name "hydra.typing.TypeParameter",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "name"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The name of the type parameter")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "constraints"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.core.TypeClassConstraint"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Any type class constraints on the type parameter")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A type parameter of a term, with an optional list of type class constraints")))]))}))),+      (+        Core.Name "hydra.typing.TypeSubst",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.core.Name")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "hydra.core.Type"))}))),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A substitution of type variables for types")))]))}))),+      (+        Core.Name "hydra.util.CaseConvention",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "camel"),+              Core.fieldTypeType = Core.TypeUnit},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "pascal"),+              Core.fieldTypeType = Core.TypeUnit},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "lowerSnake"),+              Core.fieldTypeType = Core.TypeUnit},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "upperSnake"),+              Core.fieldTypeType = Core.TypeUnit}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A naming convention for symbols, such as camelCase or snake_case")))]))}))),+      (+        Core.Name "hydra.util.Comparison",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "lessThan"),+              Core.fieldTypeType = Core.TypeUnit},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "equalTo"),+              Core.fieldTypeType = Core.TypeUnit},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "greaterThan"),+              Core.fieldTypeType = Core.TypeUnit}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "An equality judgement: less than, equal to, or greater than")))]))}))),+      (+        Core.Name "hydra.util.FileExtension",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeWrap (Core.TypeLiteral Core.LiteralTypeString)),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A file extension (without the dot), e.g. \"json\" or \"py\"")))]))}))),+      (+        Core.Name "hydra.util.ModuleNames",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeForall (Core.ForallType {+            Core.forallTypeParameter = (Core.Name "n"),+            Core.forallTypeBody = (Core.TypeRecord [+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "focus"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypePair (Core.PairType {+                    Core.pairTypeFirst = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")),+                    Core.pairTypeSecond = (Core.TypeVariable (Core.Name "n"))})),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (+                      Core.TermVariable (Core.Name "description"),+                      (Core.TermLiteral (Core.LiteralString "The module name in focus, together with its associated value")))]))}))},+              Core.FieldType {+                Core.fieldTypeName = (Core.Name "mapping"),+                Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = (Core.TypeMap (Core.MapType {+                    Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")),+                    Core.mapTypeValues = (Core.TypeVariable (Core.Name "n"))})),+                  Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                    (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "A mapping of module names to values")))]))}))}])})),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A mapping from module names to values of type n, with a focus on one module name")))]))}))),+      (+        Core.Name "hydra.util.Precision",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeUnion [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "arbitrary"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = Core.TypeUnit,+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Arbitrary precision")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "bits"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (+                    Core.TermVariable (Core.Name "description"),+                    (Core.TermLiteral (Core.LiteralString "Precision to a specified number of bits")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "Numeric precision: arbitrary precision, or precision to a specified number of bits")))]))}))),+      (+        Core.Name "hydra.util.QualifiedName",+        (Core.TypeAnnotated (Core.AnnotatedType {+          Core.annotatedTypeBody = (Core.TypeRecord [+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "moduleName"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeOptional (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName"))),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The optional module name")))]))}))},+            Core.FieldType {+              Core.fieldTypeName = (Core.Name "local"),+              Core.fieldTypeType = (Core.TypeAnnotated (Core.AnnotatedType {+                Core.annotatedTypeBody = (Core.TypeLiteral Core.LiteralTypeString),+                Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+                  (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "The local name")))]))}))}]),+          Core.annotatedTypeAnnotation = (Core.TermMap (M.fromList [+            (+              Core.TermVariable (Core.Name "description"),+              (Core.TermLiteral (Core.LiteralString "A qualified name consisting of an optional module name together with a mandatory local name")))]))})))]
+ src/main/haskell/Hydra/Json/Decode.hs view
@@ -0,0 +1,288 @@+-- Note: this is an automatically generated file. Do not edit.+-- | JSON decoding for Hydra terms. Converts JSON Values to Terms using Either for error handling.++module Hydra.Json.Decode where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+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.Json.Model as Model+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 LibLiterals+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Literals as Literals+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Decode a JSON value to a float term. Finite values arrive as JSON numbers; NaN/Inf/-0.0 arrive as JSON string sentinels. Float32 and Float64 are symmetric.+decodeFloat :: Core.FloatType -> Model.Value -> Either String Core.Term+decodeFloat ft value =+    case ft of+      Core.FloatTypeFloat32 -> case value of+        Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 (LibLiterals.decimalToFloat32 v1))))+        Model.ValueString v1 -> Optionals.cases (parseSpecialFloat32 v1) (Left (Strings.cat [+          "invalid float32 sentinel: ",+          v1])) (\v -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 v))))+        _ -> Left "expected number or special float string for float32"+      Core.FloatTypeFloat64 -> case value of+        Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (LibLiterals.decimalToFloat64 v1))))+        Model.ValueString v1 -> Optionals.cases (parseSpecialFloat v1) (Left (Strings.cat [+          "invalid float64 sentinel: ",+          v1])) (\v -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 v))))+        _ -> Left "expected number or special float string for float64"+-- | Decode a JSON value to an integer term. Small ints from numbers; large ints from strings.+decodeInteger :: Core.IntegerType -> Model.Value -> Either String Core.Term+decodeInteger it value =+    case it of+      Core.IntegerTypeBigint ->+        let strResult = expectString value+        in (Eithers.either (\err -> Left err) (\s ->+          let parsed = LibLiterals.readBigint s+          in (Optionals.cases parsed (Left (Strings.cat [+            "invalid bigint: ",+            s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueBigint v)))))) strResult)+      Core.IntegerTypeInt64 ->+        let strResult = expectString value+        in (Eithers.either (\err -> Left err) (\s ->+          let parsed = LibLiterals.readInt64 s+          in (Optionals.cases parsed (Left (Strings.cat [+            "invalid int64: ",+            s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 v)))))) strResult)+      Core.IntegerTypeUint64 ->+        let strResult = expectString value+        in (Eithers.either (\err -> Left err) (\s ->+          let parsed = LibLiterals.readUint64 s+          in (Optionals.cases parsed (Left (Strings.cat [+            "invalid uint64: ",+            s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint64 v)))))) strResult)+      Core.IntegerTypeInt8 ->+        let numResult = expectNumber value+        in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt8 (LibLiterals.bigintToInt8 (LibLiterals.decimalToBigint n))))) numResult)+      Core.IntegerTypeInt16 ->+        let numResult = expectNumber value+        in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt16 (LibLiterals.bigintToInt16 (LibLiterals.decimalToBigint n))))) numResult)+      Core.IntegerTypeInt32 ->+        let numResult = expectNumber value+        in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 (LibLiterals.bigintToInt32 (LibLiterals.decimalToBigint n))))) numResult)+      Core.IntegerTypeUint8 ->+        let numResult = expectNumber value+        in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint8 (LibLiterals.bigintToUint8 (LibLiterals.decimalToBigint n))))) numResult)+      Core.IntegerTypeUint16 ->+        let numResult = expectNumber value+        in (Eithers.map (\n -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint16 (LibLiterals.bigintToUint16 (LibLiterals.decimalToBigint n))))) numResult)+      Core.IntegerTypeUint32 -> case value of+        Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 (LibLiterals.bigintToUint32 (LibLiterals.decimalToBigint v1)))))+        Model.ValueString v1 ->+          let parsed = LibLiterals.readUint32 v1+          in (Optionals.cases parsed (Left (Strings.cat [+            "invalid uint32: ",+            v1])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 v)))))+        _ -> Left "expected number or string for uint32"+-- | Decode a JSON value to a literal term+decodeLiteral :: Core.LiteralType -> Model.Value -> Either String Core.Term+decodeLiteral lt value =+    case lt of+      Core.LiteralTypeBinary ->+        let strResult = expectString value+        in (Eithers.map (\s -> Core.TermLiteral (Core.LiteralBinary (LibLiterals.stringToBinary s))) strResult)+      Core.LiteralTypeBoolean -> case value of+        Model.ValueBoolean v1 -> Right (Core.TermLiteral (Core.LiteralBoolean v1))+        _ -> Left "expected boolean"+      Core.LiteralTypeDecimal -> case value of+        Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralDecimal v1))+        _ -> Left "expected number for decimal"+      Core.LiteralTypeFloat v0 -> decodeFloat v0 value+      Core.LiteralTypeInteger v0 -> decodeInteger v0 value+      Core.LiteralTypeString ->+        let strResult = expectString value+        in (Eithers.map (\s -> Core.TermLiteral (Core.LiteralString s)) strResult)+-- | Extract an array from a JSON value+expectArray :: Model.Value -> Either String [Model.Value]+expectArray value =+    case value of+      Model.ValueArray v0 -> Right v0+      _ -> Left "expected array"+-- | Extract a number from a JSON value+expectNumber :: Model.Value -> Either String Sci.Scientific+expectNumber value =+    case value of+      Model.ValueNumber v0 -> Right v0+      _ -> Left "expected number"+-- | Extract an object from a JSON value as a name-keyed map. Field order is not preserved here; decoding looks fields up by name.+expectObject :: Model.Value -> Either String (M.Map String Model.Value)+expectObject value =+    case value of+      Model.ValueObject v0 -> Right (Maps.fromList v0)+      _ -> Left "expected object"+-- | Extract a string from a JSON value+expectString :: Model.Value -> Either String String+expectString value =+    case value of+      Model.ValueString v0 -> Right v0+      _ -> Left "expected string"+-- | Decode a JSON value to a Hydra term given a type and type name. Returns Left for type mismatches.+fromJson :: M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> Model.Value -> Either String Core.Term+fromJson types tname typ value =++      let stripped = Strip.deannotateType typ+      in case stripped of+        Core.TypeLiteral v0 -> decodeLiteral v0 value+        Core.TypeList v0 ->+          let decodeElem = \v -> fromJson types tname v0 v+              arrResult = expectArray value+          in (Eithers.either (\err -> Left err) (\arr ->+            let decoded = Eithers.mapList decodeElem arr+            in (Eithers.map (\ts -> Core.TermList ts) decoded)) arrResult)+        Core.TypeSet v0 ->+          let decodeElem = \v -> fromJson types tname v0 v+              arrResult = expectArray value+          in (Eithers.either (\err -> Left err) (\arr ->+            let decoded = Eithers.mapList decodeElem arr+            in (Eithers.map (\elems -> Core.TermSet (Sets.fromList elems)) decoded)) arrResult)+        Core.TypeOptional v0 ->+          let innerStripped = Strip.deannotateType v0+              isNestedMaybe =+                      case innerStripped of+                        Core.TypeOptional _ -> True+                        _ -> False+          in (Logic.ifElse isNestedMaybe (+            let decodeJust =+                    \arr -> Optionals.cases (Lists.maybeHead arr) (Left "expected single-element array for Just") (\firstVal -> Eithers.map (\v -> Core.TermOptional (Just v)) (fromJson types tname v0 firstVal))+                decodeMaybeArray =+                        \arr ->+                          let len = Lists.length arr+                          in (Logic.ifElse (Equality.equal len 0) (Right (Core.TermOptional Nothing)) (Logic.ifElse (Equality.equal len 1) (decodeJust arr) (Left "expected single-element array for Just")))+            in case value of+              Model.ValueNull -> Right (Core.TermOptional Nothing)+              Model.ValueArray v1 -> decodeMaybeArray v1+              _ -> Left "expected null or single-element array for nested Maybe") (case value of+            Model.ValueNull -> Right (Core.TermOptional Nothing)+            _ -> Eithers.map (\v -> Core.TermOptional (Just v)) (fromJson types tname v0 value)))+        Core.TypeRecord v0 ->+          let objResult = expectObject value+          in (Eithers.either (\err -> Left err) (\obj ->+            let decodeField =+                    \ft ->+                      let fname = Core.fieldTypeName ft+                          ftype = Core.fieldTypeType ft+                          mval = Maps.lookup (Core.unName fname) obj+                          defaultVal = Model.ValueNull+                          jsonVal = Optionals.fromOptional defaultVal mval+                          decoded = fromJson types tname ftype jsonVal+                      in (Eithers.map (\v -> Core.Field {+                        Core.fieldName = fname,+                        Core.fieldTerm = v}) decoded)+                decodedFields = Eithers.mapList decodeField v0+            in (Eithers.map (\fs -> Core.TermRecord (Core.Record {+              Core.recordTypeName = tname,+              Core.recordFields = fs})) decodedFields)) objResult)+        Core.TypeUnion v0 ->+          let decodeVariant =+                  \key -> \val -> \ftype ->+                    let jsonVal = Optionals.fromOptional Model.ValueNull val+                        decoded = fromJson types tname ftype jsonVal+                    in (Eithers.map (\v -> Core.TermInject (Core.Injection {+                      Core.injectionTypeName = tname,+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name key),+                        Core.fieldTerm = v}})) decoded)+              findAndDecode =+                      \key -> \val -> \fts -> Optionals.cases (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) key) fts) (Left (Strings.cat [+                        "unknown variant: ",+                        key])) (\ft -> decodeVariant key val (Core.fieldTypeType ft))+              decodeSingleKey =+                      \obj -> Optionals.cases (Lists.maybeHead (Maps.keys obj)) (Left "expected single-key object for union") (\k -> findAndDecode k (Maps.lookup k obj) v0)+              processUnion =+                      \obj -> Logic.ifElse (Equality.equal (Lists.length (Maps.keys obj)) 1) (decodeSingleKey obj) (Left "expected single-key object for union")+              objResult = expectObject value+          in (Eithers.either (\err -> Left err) (\obj -> processUnion obj) objResult)+        Core.TypeUnit ->+          let objResult = expectObject value+          in (Eithers.map (\_2 -> Core.TermUnit) objResult)+        Core.TypeWrap v0 ->+          let decoded = fromJson types tname v0 value+          in (Eithers.map (\v -> Core.TermWrap (Core.WrappedTerm {+            Core.wrappedTermTypeName = tname,+            Core.wrappedTermBody = v})) decoded)+        Core.TypeMap v0 ->+          let keyType = Core.mapTypeKeys v0+              valType = Core.mapTypeValues v0+              arrResult = expectArray value+          in (Eithers.either (\err -> Left err) (\arr ->+            let decodeEntry =+                    \entryJson ->+                      let objResult = expectObject entryJson+                      in (Eithers.either (\err -> Left err) (\entryObj ->+                        let keyJson = Maps.lookup "key" entryObj+                            valJson = Maps.lookup "value" entryObj+                        in (Optionals.cases keyJson (Left "missing key in map entry") (\kj -> Optionals.cases valJson (Left "missing value in map entry") (\vj ->+                          let decodedKey = fromJson types tname keyType kj+                              decodedVal = fromJson types tname valType vj+                          in (Eithers.either (\err -> Left err) (\k -> Eithers.map (\v -> (k, v)) decodedVal) decodedKey))))) objResult)+                entries = Eithers.mapList decodeEntry arr+            in (Eithers.map (\es -> Core.TermMap (Maps.fromList es)) entries)) arrResult)+        Core.TypePair v0 ->+          let firstType = Core.pairTypeFirst v0+              secondType = Core.pairTypeSecond v0+              objResult = expectObject value+          in (Eithers.either (\err -> Left err) (\obj ->+            let firstJson = Maps.lookup "first" obj+                secondJson = Maps.lookup "second" obj+            in (Optionals.cases firstJson (Left "missing first in pair") (\fj -> Optionals.cases secondJson (Left "missing second in pair") (\sj ->+              let decodedFirst = fromJson types tname firstType fj+                  decodedSecond = fromJson types tname secondType sj+              in (Eithers.either (\err -> Left err) (\f -> Eithers.map (\s -> Core.TermPair (f, s)) decodedSecond) decodedFirst))))) objResult)+        Core.TypeEither v0 ->+          let leftType = Core.eitherTypeLeft v0+              rightType = Core.eitherTypeRight v0+              objResult = expectObject value+          in (Eithers.either (\err -> Left err) (\obj ->+            let leftJson = Maps.lookup "left" obj+                rightJson = Maps.lookup "right" obj+            in (Optionals.cases leftJson (Optionals.cases rightJson (Left "expected left or right in Either") (\rj ->+              let decoded = fromJson types tname rightType rj+              in (Eithers.map (\v -> Core.TermEither (Right v)) decoded))) (\lj ->+              let decoded = fromJson types tname leftType lj+              in (Eithers.map (\v -> Core.TermEither (Left v)) decoded)))) objResult)+        Core.TypeVariable v0 ->+          let lookedUp = Maps.lookup v0 types+          in (Optionals.cases lookedUp (Left (Strings.cat [+            "unknown type variable: ",+            (Core.unName v0)])) (\resolvedType -> fromJson types v0 resolvedType value))+        _ -> Left (Strings.cat [+          "unsupported type for JSON decoding: ",+          (ShowCore.type_ typ)])+-- | Parse an IEEE sentinel string (NaN, Infinity, -Infinity, -0.0) to a float64. Returns Nothing for unrecognized strings.+parseSpecialFloat :: String -> Maybe Double+parseSpecialFloat s =+    Logic.ifElse (Logic.or (Equality.equal s "NaN") (Logic.or (Equality.equal s "Infinity") (Logic.or (Equality.equal s "-Infinity") (Equality.equal s "-0.0")))) (LibLiterals.readFloat64 s) Nothing+-- | Parse an IEEE sentinel string (NaN, Infinity, -Infinity, -0.0) to a float32. Returns Nothing for unrecognized strings.+parseSpecialFloat32 :: String -> Maybe Float+parseSpecialFloat32 s =+    Logic.ifElse (Logic.or (Equality.equal s "NaN") (Logic.or (Equality.equal s "Infinity") (Logic.or (Equality.equal s "-Infinity") (Equality.equal s "-0.0")))) (LibLiterals.readFloat32 s) Nothing
+ src/main/haskell/Hydra/Json/Decoding.hs view
@@ -0,0 +1,65 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Decoding functions for JSON data++module Hydra.Json.Decoding where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Decode a JSON array using a decoder for elements+decodeArray :: (Model.Value -> Either String t0) -> Model.Value -> Either String [t0]+decodeArray decodeElem x =+    case x of+      Model.ValueArray v0 -> Eithers.mapList decodeElem v0+      _ -> Left "expected an array"+-- | Decode a JSON boolean value+decodeBoolean :: Model.Value -> Either String Bool+decodeBoolean x =+    case x of+      Model.ValueBoolean v0 -> Right v0+      _ -> Left "expected a boolean"+-- | Decode a required field from a JSON object+decodeField :: (t0 -> Either String t1) -> String -> M.Map String t0 -> Either String t1+decodeField decodeValue name m =+    Eithers.bind (decodeOptionalField decodeValue name m) (\mf -> Optionals.cases mf (Left (Strings.cat2 "missing field: " name)) (\f -> Right f))+-- | Decode a JSON object value to a name-keyed map. Field order is not preserved; decoding looks fields up by name.+decodeObject :: Model.Value -> Either String (M.Map String Model.Value)+decodeObject x =+    case x of+      Model.ValueObject v0 -> Right (Maps.fromList v0)+      _ -> Left "expected an object"+-- | Decode an optional field from a JSON object+decodeOptionalField :: Ord t3 => ((t0 -> Either t1 t2) -> t3 -> M.Map t3 t0 -> Either t1 (Maybe t2))+decodeOptionalField decodeValue name m =+    Optionals.cases (Maps.lookup name m) (Right Nothing) (\v -> Eithers.map (\x -> Just x) (decodeValue v))+-- | Decode a JSON string value+decodeString :: Model.Value -> Either String String+decodeString x =+    case x of+      Model.ValueString v0 -> Right v0+      _ -> Left "expected a string"
+ src/main/haskell/Hydra/Json/Encode.hs view
@@ -0,0 +1,276 @@+-- Note: this is an automatically generated file. Do not edit.+-- | JSON encoding for Hydra terms. Converts Terms to JSON Values using Either for error handling.++module Hydra.Json.Encode where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+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.Json.Model as Model+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 LibLiterals+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Literals as Literals+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Encode a float value to JSON. Finite values become JSON numbers (shortest round-trip); IEEE specials (NaN/Inf/-0.0) become JSON strings. Float32 and Float64 are symmetric; the schema disambiguates precision on decode.+encodeFloat :: Core.FloatValue -> Either t0 Model.Value+encodeFloat fv =+    case fv of+      Core.FloatValueFloat32 v0 ->+        let s = LibLiterals.showFloat32 v0+        in (Logic.ifElse (requiresJsonStringSentinel s) (Right (Model.ValueString s)) (Right (Model.ValueNumber (LibLiterals.float32ToDecimal v0))))+      Core.FloatValueFloat64 v0 ->+        let s = LibLiterals.showFloat64 v0+        in (Logic.ifElse (requiresJsonStringSentinel s) (Right (Model.ValueString s)) (Right (Model.ValueNumber (LibLiterals.float64ToDecimal v0))))+-- | Encode an integer value to JSON. Small ints use native numbers; large ints use strings.+encodeInteger :: Core.IntegerValue -> Either t0 Model.Value+encodeInteger iv =+    case iv of+      Core.IntegerValueBigint v0 -> Right (Model.ValueString (LibLiterals.showBigint v0))+      Core.IntegerValueInt64 v0 -> Right (Model.ValueString (LibLiterals.showInt64 v0))+      Core.IntegerValueUint64 v0 -> Right (Model.ValueString (LibLiterals.showUint64 v0))+      Core.IntegerValueInt8 v0 -> Right (Model.ValueNumber (LibLiterals.bigintToDecimal (LibLiterals.int8ToBigint v0)))+      Core.IntegerValueInt16 v0 -> Right (Model.ValueNumber (LibLiterals.bigintToDecimal (LibLiterals.int16ToBigint v0)))+      Core.IntegerValueInt32 v0 -> Right (Model.ValueNumber (LibLiterals.bigintToDecimal (LibLiterals.int32ToBigint v0)))+      Core.IntegerValueUint8 v0 -> Right (Model.ValueNumber (LibLiterals.bigintToDecimal (LibLiterals.uint8ToBigint v0)))+      Core.IntegerValueUint16 v0 -> Right (Model.ValueNumber (LibLiterals.bigintToDecimal (LibLiterals.uint16ToBigint v0)))+      Core.IntegerValueUint32 v0 -> Right (Model.ValueNumber (LibLiterals.bigintToDecimal (LibLiterals.uint32ToBigint v0)))+-- | Encode a Hydra literal to a JSON value+encodeLiteral :: Core.Literal -> Either t0 Model.Value+encodeLiteral lit =+    case lit of+      Core.LiteralBinary v0 -> Right (Model.ValueString (LibLiterals.binaryToString v0))+      Core.LiteralBoolean v0 -> Right (Model.ValueBoolean v0)+      Core.LiteralDecimal v0 -> Right (Model.ValueNumber v0)+      Core.LiteralFloat v0 -> encodeFloat v0+      Core.LiteralInteger v0 -> encodeInteger v0+      Core.LiteralString v0 -> Right (Model.ValueString v0)+-- | True for IEEE sentinel strings that JSON must escape as a string to preserve.+requiresJsonStringSentinel :: String -> Bool+requiresJsonStringSentinel s =+    Logic.or (Equality.equal s "NaN") (Logic.or (Equality.equal s "Infinity") (Logic.or (Equality.equal s "-Infinity") (Equality.equal s "-0.0")))+-- | Encode a Hydra term to a JSON value given a type and type name. Returns Left for unsupported constructs.+toJson :: M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> Core.Term -> Either String Model.Value+toJson types tname typ term =++      let stripped = Strip.deannotateType typ+          strippedTerm = Strip.deannotateTerm term+      in case stripped of+        Core.TypeLiteral _ -> case strippedTerm of+          Core.TermLiteral v1 -> encodeLiteral v1+          _ -> Left "expected literal term"+        Core.TypeList v0 -> case strippedTerm of+          Core.TermList v1 ->+            let results = Eithers.mapList (\t -> toJson types tname v0 t) v1+            in (Eithers.map (\vs -> Model.ValueArray vs) results)+          _ -> Left "expected list term"+        Core.TypeSet v0 -> case strippedTerm of+          Core.TermSet v1 ->+            let terms = Sets.toList v1+                results = Eithers.mapList (\t -> toJson types tname v0 t) terms+            in (Eithers.map (\vs -> Model.ValueArray vs) results)+          _ -> Left "expected set term"+        Core.TypeOptional v0 ->+          let innerStripped = Strip.deannotateType v0+              isNestedMaybe =+                      case innerStripped of+                        Core.TypeOptional _ -> True+                        _ -> False+          in case strippedTerm of+            Core.TermOptional v1 -> Optionals.cases v1 (Right Model.ValueNull) (\v ->+              let encoded = toJson types tname v0 v+              in (Logic.ifElse isNestedMaybe (Eithers.map (\ev -> Model.ValueArray [+                ev]) encoded) encoded))+            _ -> Left "expected maybe term"+        Core.TypeRecord v0 -> case strippedTerm of+          Core.TermRecord v1 ->+            let isSimpleMaybe =+                    \ftype -> case (Strip.deannotateType ftype) of+                      Core.TypeOptional v2 -> case (Strip.deannotateType v2) of+                        Core.TypeOptional _ -> False+                        _ -> True+                      _ -> False+                encodeFieldWithType =+                        \ft -> \f ->+                          let fname = Core.unName (Core.fieldName f)+                              fterm = Core.fieldTerm f+                              ftype = Core.fieldTypeType ft+                          in (Logic.ifElse (isSimpleMaybe ftype) (case (Strip.deannotateTerm fterm) of+                            Core.TermOptional v2 -> Optionals.cases v2 (Right Nothing) (\v ->+                              let innerType =+                                      case (Strip.deannotateType ftype) of+                                        Core.TypeOptional v3 -> v3+                                        _ -> ftype+                                  encoded = toJson types tname innerType v+                              in (Eithers.map (\ev -> Just (fname, ev)) encoded))+                            _ -> Left "expected maybe term for optional field") (+                            let encoded = toJson types tname ftype fterm+                            in (Eithers.map (\ev -> Just (fname, ev)) encoded)))+                fieldTypes = v0+                fields = Core.recordFields v1+                encodedPairs =+                        Eithers.mapList (\ftf -> encodeFieldWithType (Pairs.first ftf) (Pairs.second ftf)) (Lists.zip fieldTypes fields)+            in (Eithers.map (\pairs -> Model.ValueObject (Optionals.cat pairs)) encodedPairs)+          _ -> Left "expected record term"+        Core.TypeUnion v0 -> case strippedTerm of+          Core.TermInject v1 ->+            let field = Core.injectionField v1+                fname = Core.unName (Core.fieldName field)+                fterm = Core.fieldTerm field+                ftypeResult =+                        Optionals.cases (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) fname) v0) (Left (Strings.cat [+                          "unknown variant: ",+                          fname])) (\ft -> Right (Core.fieldTypeType ft))+            in (Eithers.either (\err -> Left err) (\ftype ->+              let encodedUnion = toJson types tname ftype fterm+              in (Eithers.map (\v -> Model.ValueObject [+                (fname, v)]) encodedUnion)) ftypeResult)+          _ -> Left "expected union term"+        Core.TypeUnit -> Right (Model.ValueObject [])+        Core.TypeWrap v0 -> case strippedTerm of+          Core.TermWrap v1 -> toJson types tname v0 (Core.wrappedTermBody v1)+          _ -> Left "expected wrapped term"+        Core.TypeMap v0 ->+          let keyType = Core.mapTypeKeys v0+              valType = Core.mapTypeValues v0+          in case strippedTerm of+            Core.TermMap v1 ->+              let encodeEntry =+                      \kv ->+                        let k = Pairs.first kv+                            v = Pairs.second kv+                            encodedK = toJson types tname keyType k+                            encodedV = toJson types tname valType v+                        in (Eithers.either (\err -> Left err) (\ek -> Eithers.map (\ev -> Model.ValueObject [+                          ("key", ek),+                          ("value", ev)]) encodedV) encodedK)+                  entries = Eithers.mapList encodeEntry (Maps.toList v1)+              in (Eithers.map (\es -> Model.ValueArray es) entries)+            _ -> Left "expected map term"+        Core.TypePair v0 ->+          let firstType = Core.pairTypeFirst v0+              secondType = Core.pairTypeSecond v0+          in case strippedTerm of+            Core.TermPair v1 ->+              let first = Pairs.first v1+                  second = Pairs.second v1+                  encodedFirst = toJson types tname firstType first+                  encodedSecond = toJson types tname secondType second+              in (Eithers.either (\err -> Left err) (\ef -> Eithers.map (\es -> Model.ValueObject [+                ("first", ef),+                ("second", es)]) encodedSecond) encodedFirst)+            _ -> Left "expected pair term"+        Core.TypeEither v0 ->+          let leftType = Core.eitherTypeLeft v0+              rightType = Core.eitherTypeRight v0+          in case strippedTerm of+            Core.TermEither v1 -> Eithers.either (\l ->+              let encodedL = toJson types tname leftType l+              in (Eithers.map (\v -> Model.ValueObject [+                ("left", v)]) encodedL)) (\r ->+              let encodedR = toJson types tname rightType r+              in (Eithers.map (\v -> Model.ValueObject [+                ("right", v)]) encodedR)) v1+            _ -> Left "expected either term"+        Core.TypeVariable v0 ->+          let lookedUp = Maps.lookup v0 types+          in (Optionals.cases lookedUp (toJsonUntyped term) (\resolvedType -> toJson types v0 resolvedType term))+        _ -> Left (Strings.cat [+          "unsupported type for JSON encoding: ",+          (ShowCore.type_ typ)])+-- | Encode a Hydra term to a JSON value without type information. Falls back to array-wrapped Maybe encoding.+toJsonUntyped :: Core.Term -> Either String Model.Value+toJsonUntyped term =++      let stripped = Strip.deannotateTerm term+      in case stripped of+        Core.TermLiteral v0 -> encodeLiteral v0+        Core.TermList v0 ->+          let results = Eithers.mapList (\t -> toJsonUntyped t) v0+          in (Eithers.map (\vs -> Model.ValueArray vs) results)+        Core.TermSet v0 ->+          let terms = Sets.toList v0+              results = Eithers.mapList (\t -> toJsonUntyped t) terms+          in (Eithers.map (\vs -> Model.ValueArray vs) results)+        Core.TermOptional v0 -> Optionals.cases v0 (Right Model.ValueNull) (\v ->+          let encodedMaybe = toJsonUntyped v+          in (Eithers.map (\encoded -> Model.ValueArray [+            encoded]) encodedMaybe))+        Core.TermRecord v0 ->+          let encodeField =+                  \f ->+                    let fname = Core.unName (Core.fieldName f)+                        fterm = Core.fieldTerm f+                        encodedField = toJsonUntyped fterm+                    in (Eithers.map (\v -> (fname, v)) encodedField)+              fields = Core.recordFields v0+              encodedFields = Eithers.mapList encodeField fields+          in (Eithers.map (\fs -> Model.ValueObject fs) encodedFields)+        Core.TermInject v0 ->+          let field = Core.injectionField v0+              fname = Core.unName (Core.fieldName field)+              fterm = Core.fieldTerm field+              encodedUnion = toJsonUntyped fterm+          in (Eithers.map (\v -> Model.ValueObject [+            (fname, v)]) encodedUnion)+        Core.TermUnit -> Right (Model.ValueObject [])+        Core.TermWrap v0 -> toJsonUntyped (Core.wrappedTermBody v0)+        Core.TermMap v0 ->+          let encodeEntry =+                  \kv ->+                    let k = Pairs.first kv+                        v = Pairs.second kv+                        encodedK = toJsonUntyped k+                        encodedV = toJsonUntyped v+                    in (Eithers.either (\err -> Left err) (\ek -> Eithers.map (\ev -> Model.ValueObject [+                      ("key", ek),+                      ("value", ev)]) encodedV) encodedK)+              entries = Eithers.mapList encodeEntry (Maps.toList v0)+          in (Eithers.map (\es -> Model.ValueArray es) entries)+        Core.TermPair v0 ->+          let first = Pairs.first v0+              second = Pairs.second v0+              encodedFirst = toJsonUntyped first+              encodedSecond = toJsonUntyped second+          in (Eithers.either (\err -> Left err) (\ef -> Eithers.map (\es -> Model.ValueObject [+            ("first", ef),+            ("second", es)]) encodedSecond) encodedFirst)+        Core.TermEither v0 -> Eithers.either (\l ->+          let encodedL = toJsonUntyped l+          in (Eithers.map (\v -> Model.ValueObject [+            ("left", v)]) encodedL)) (\r ->+          let encodedR = toJsonUntyped r+          in (Eithers.map (\v -> Model.ValueObject [+            ("right", v)]) encodedR)) v0+        _ -> Left (Strings.cat [+          "unsupported term variant for JSON encoding: ",+          (ShowCore.term term)])
+ src/main/haskell/Hydra/Json/Model.hs view
@@ -0,0 +1,29 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A JSON syntax model. See the BNF at https://www.json.org++module Hydra.Json.Model where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | A JSON value+data Value =+  -- | A JSON array+  ValueArray [Value] |+  -- | A boolean value+  ValueBoolean Bool |+  -- | JSON's null value+  ValueNull |+  -- | A numeric value+  ValueNumber Sci.Scientific |+  -- | A JSON object as an ordered list of key/value pairs. The ordering preserves the declaration order of the record from which the object was encoded, rather than alphabetizing keys. As a consequence, equality of Value objects is order-sensitive: two objects with the same pairs in a different order are equal as JSON, but not as Hydra Values.+  ValueObject [(String, Value)] |+  -- | A string value+  ValueString String+  deriving (Eq, Ord, Read, Show)+_Value = Core.Name "hydra.json.model.Value"+_Value_array = Core.Name "array"+_Value_boolean = Core.Name "boolean"+_Value_null = Core.Name "null"+_Value_number = Core.Name "number"+_Value_object = Core.Name "object"+_Value_string = Core.Name "string"
+ src/main/haskell/Hydra/Json/Parser.hs view
@@ -0,0 +1,124 @@+-- Note: this is an automatically generated file. Do not edit.+-- | JSON parser using Hydra parser combinators++module Hydra.Json.Parser where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsers as Parsers+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Hydra.Haskell.Lib.Literals as Literals+-- | Parse a single digit (0-9)+digit :: Parsing.Parser Int+digit = Parsers.satisfy (\c -> Logic.and (Equality.gte c 48) (Equality.lte c 57))+-- | Parse one or more digits as a string+digits :: Parsing.Parser String+digits = Parsers.map Strings.fromList (Parsers.some digit)+-- | Parse a JSON array+jsonArray :: Parsing.Parser Model.Value+jsonArray =+    Parsers.map (\x -> Model.ValueArray x) (Parsers.between (token (Parsers.char 91)) (token (Parsers.char 93)) (Parsers.sepBy (Parsers.lazy (\_ -> jsonValue)) (token (Parsers.char 44))))+-- | Parse JSON boolean (true or false)+jsonBool :: Parsing.Parser Model.Value+jsonBool =+    Parsers.alt (Parsers.map (\_ -> Model.ValueBoolean True) (token (Parsers.string "true"))) (Parsers.map (\_ -> Model.ValueBoolean False) (token (Parsers.string "false")))+-- | Parse a JSON escape sequence after the backslash+jsonEscapeChar :: Parsing.Parser Int+jsonEscapeChar =+    Parsers.choice [+      Parsers.map (\_ -> 34) (Parsers.char 34),+      (Parsers.map (\_ -> 92) (Parsers.char 92)),+      (Parsers.map (\_ -> 47) (Parsers.char 47)),+      (Parsers.map (\_ -> 8) (Parsers.char 98)),+      (Parsers.map (\_ -> 12) (Parsers.char 102)),+      (Parsers.map (\_ -> 10) (Parsers.char 110)),+      (Parsers.map (\_ -> 13) (Parsers.char 114)),+      (Parsers.map (\_ -> 9) (Parsers.char 116))]+-- | Parse the optional exponent part of a JSON number+jsonExponentPart :: Parsing.Parser (Maybe String)+jsonExponentPart =+    Parsers.optional (Parsers.bind (Parsers.satisfy (\c -> Logic.or (Equality.equal c 101) (Equality.equal c 69))) (\_ -> Parsers.bind (Parsers.optional (Parsers.satisfy (\c -> Logic.or (Equality.equal c 43) (Equality.equal c 45)))) (\sign -> Parsers.map (\digits -> Strings.cat2 (Strings.cat2 "e" (Optionals.cases sign "" (\arg_ -> Strings.fromList (Lists.pure arg_)))) digits) digits)))+-- | Parse the optional fractional part of a JSON number+jsonFractionPart :: Parsing.Parser (Maybe String)+jsonFractionPart = Parsers.optional (Parsers.bind (Parsers.char 46) (\_ -> Parsers.map (\d -> Strings.cat2 "." d) digits))+-- | Parse the integer part of a JSON number (optional minus, then digits)+jsonIntegerPart :: Parsing.Parser String+jsonIntegerPart =+    Parsers.bind (Parsers.optional (Parsers.char 45)) (\sign -> Parsers.bind digits (\digits -> Parsers.pure (Optionals.cases sign digits (\_ -> Strings.cat2 "-" digits))))+-- | Parse a JSON object key-value pair+jsonKeyValue :: Parsing.Parser (String, Model.Value)+jsonKeyValue =+    Parsers.bind (token (Parsers.bind (Parsers.char 34) (\_ -> Parsers.bind (Parsers.many jsonStringChar) (\chars -> Parsers.bind (Parsers.char 34) (\_2 -> Parsers.pure (Strings.fromList chars)))))) (\key -> Parsers.bind (token (Parsers.char 58)) (\_ -> Parsers.map (\v -> (key, v)) (Parsers.lazy (\_2 -> jsonValue))))+-- | Parse JSON null value+jsonNull :: Parsing.Parser Model.Value+jsonNull = Parsers.map (\_ -> Model.ValueNull) (token (Parsers.string "null"))+-- | Parse a JSON number (integer, decimal, or scientific notation)+jsonNumber :: Parsing.Parser Model.Value+jsonNumber =+    token (Parsers.bind jsonIntegerPart (\intPart -> Parsers.bind jsonFractionPart (\fracPart -> Parsers.bind jsonExponentPart (\expPart ->+      let numStr =+              Strings.cat2 (Strings.cat2 intPart (Optionals.cases fracPart "" Equality.identity)) (Optionals.cases expPart "" Equality.identity)+      in (Parsers.pure (Model.ValueNumber (Optionals.cases (Literals.readDecimal numStr) (Literals.stringToDecimal "0.0") Equality.identity)))))))+-- | Parse a JSON object+jsonObject :: Parsing.Parser Model.Value+jsonObject =+    Parsers.map (\x -> Model.ValueObject x) (Parsers.between (token (Parsers.char 123)) (token (Parsers.char 125)) (Parsers.sepBy jsonKeyValue (token (Parsers.char 44))))+-- | Parse a JSON string value+jsonString :: Parsing.Parser Model.Value+jsonString =+    token (Parsers.bind (Parsers.char 34) (\_ -> Parsers.bind (Parsers.many jsonStringChar) (\chars -> Parsers.bind (Parsers.char 34) (\_2 -> Parsers.pure (Model.ValueString (Strings.fromList chars))))))+-- | Parse a single character in a JSON string (handling escapes)+jsonStringChar :: Parsing.Parser Int+jsonStringChar =+    Parsers.alt (Parsers.bind (Parsers.char 92) (\_ -> jsonEscapeChar)) (Parsers.satisfy (\c -> Logic.and (Logic.not (Equality.equal c 34)) (Logic.not (Equality.equal c 92))))+-- | Parse any JSON value+jsonValue :: Parsing.Parser Model.Value+jsonValue =+    Parsers.choice [+      jsonNull,+      jsonBool,+      jsonNumber,+      jsonString,+      jsonArray,+      jsonObject]+-- | Parse a JSON document from a string+parseJson :: String -> Parsing.ParseResult Model.Value+parseJson input =+    Parsing.unParser (Parsers.bind whitespace (\_ -> Parsers.bind jsonValue (\v -> Parsers.bind whitespace (\_2 -> Parsers.bind Parsers.eof (\_3 -> Parsers.pure v))))) input+-- | Parse a token followed by optional whitespace+token :: Parsing.Parser t0 -> Parsing.Parser t0+token p = Parsers.bind p (\x -> Parsers.bind whitespace (\_ -> Parsers.pure x))+-- | Parse zero or more JSON whitespace characters (space, tab, newline, carriage return)+whitespace :: Parsing.Parser ()+whitespace =+    Parsers.map (\_ -> ()) (Parsers.many (Parsers.satisfy (\c -> Lists.foldl Logic.or False [+      Equality.equal c 32,+      (Equality.equal c 9),+      (Equality.equal c 10),+      (Equality.equal c 13)])))
+ src/main/haskell/Hydra/Json/Writer.hs view
@@ -0,0 +1,90 @@+-- Note: this is an automatically generated file. Do not edit.+-- | JSON serialization functions using the Hydra AST++module Hydra.Json.Writer where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Math as Math+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Serialization as Serialization+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | The colon operator used to separate keys and values in JSON objects+colonOp :: Ast.Op+colonOp =+    Ast.Op {+      Ast.opSymbol = (Ast.Symbol ":"),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsNone,+        Ast.paddingRight = Ast.WsSpace},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone}+-- | Encode a byte (0..255) as a two-character lowercase hex string. Non-byte inputs yield placeholder '?' characters.+hexByte :: Int -> String+hexByte c =++      let nibble =+              \i -> Optionals.fromOptional "?" (Optionals.map (\ch -> Strings.fromList (Lists.pure ch)) (Strings.maybeCharAt i "0123456789abcdef"))+          hi = nibble (Optionals.fromOptional 0 (Math.maybeDiv c 16))+          lo = nibble (Optionals.fromOptional 0 (Math.maybeMod c 16))+      in (Strings.cat2 hi lo)+-- | Escape and quote a string for JSON output+jsonString :: String -> String+jsonString s =++      let hexEscape = \c -> Strings.cat2 "\\u00" (hexByte c)+          escape =+                  \c -> Logic.ifElse (Equality.equal c 34) "\\\"" (Logic.ifElse (Equality.equal c 92) "\\\\" (Logic.ifElse (Equality.equal c 8) "\\b" (Logic.ifElse (Equality.equal c 12) "\\f" (Logic.ifElse (Equality.equal c 10) "\\n" (Logic.ifElse (Equality.equal c 13) "\\r" (Logic.ifElse (Equality.equal c 9) "\\t" (Logic.ifElse (Equality.lt c 32) (hexEscape c) (Strings.fromList (Lists.pure c)))))))))+          escaped = Strings.cat (Lists.map escape (Strings.toList s))+      in (Strings.cat2 (Strings.cat2 "\"" escaped) "\"")+-- | Convert a key-value pair to an AST expression+keyValueToExpr :: (String, Model.Value) -> Ast.Expr+keyValueToExpr pair =++      let key = Pairs.first pair+          value = Pairs.second pair+      in (Serialization.ifx colonOp (Serialization.cst (jsonString key)) (valueToExpr value))+-- | Serialize a JSON value to a string+printJson :: Model.Value -> String+printJson value = Serialization.printExpr (valueToExpr value)+-- | Convert a JSON value to an AST expression for serialization+valueToExpr :: Model.Value -> Ast.Expr+valueToExpr value =+    case value of+      Model.ValueArray v0 -> Serialization.bracketListAdaptive (Lists.map valueToExpr v0)+      Model.ValueBoolean v0 -> Serialization.cst (Logic.ifElse v0 "true" "false")+      Model.ValueNull -> Serialization.cst "null"+      Model.ValueNumber v0 ->+        let rounded = Literals.decimalToBigint v0+            shown = Literals.showDecimal v0+            isWhole = Equality.equal v0 (Literals.bigintToDecimal rounded)+            plain = Literals.showBigint rounded+        in (Serialization.cst (Logic.ifElse (Logic.and isWhole (Equality.lte (Strings.length plain) (Strings.length shown))) plain shown))+      Model.ValueObject v0 -> Serialization.bracesListAdaptive (Lists.map keyValueToExpr v0)+      Model.ValueString v0 -> Serialization.cst (jsonString v0)
+ src/main/haskell/Hydra/Json/Yaml/Decode.hs view
@@ -0,0 +1,71 @@+-- Note: this is an automatically generated file. Do not edit.+-- | YAML-to-JSON decoding. Converts YAML Nodes to JSON Values (may fail for non-JSON YAML), and YAML Nodes to Hydra Terms via JSON.++module Hydra.Json.Yaml.Decode where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Decode as Decode+import qualified Hydra.Json.Model as JsonModel+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Literals as Literals+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import qualified Hydra.Yaml.Model as YamlModel+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Decode a YAML node to a Hydra term via JSON decoding.+fromYaml :: M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> YamlModel.Node -> Either String Core.Term+fromYaml types tname typ node =++      let jsonResult = yamlToJson node+      in (Eithers.either (\err -> Left err) (\json -> Decode.fromJson types tname typ json) jsonResult)+-- | Convert a YAML node to a JSON value. Fails for non-JSON YAML features (e.g. non-string mapping keys).+yamlToJson :: YamlModel.Node -> Either String JsonModel.Value+yamlToJson node =+    case node of+      YamlModel.NodeMapping v0 ->+        let convertEntry =+                \kv ->+                  let keyNode = Pairs.first kv+                      valNode = Pairs.second kv+                      keyResult =+                              case keyNode of+                                YamlModel.NodeScalar v1 -> case v1 of+                                  YamlModel.ScalarStr v2 -> Right v2+                                  _ -> Left "non-string YAML mapping key"+                                _ -> Left "non-scalar YAML mapping key"+                  in (Eithers.either (\err -> Left err) (\key ->+                    let valResult = yamlToJson valNode+                    in (Eithers.map (\v -> (key, v)) valResult)) keyResult)+            entries = Eithers.mapList convertEntry (Maps.toList v0)+        in (Eithers.map (\es -> JsonModel.ValueObject es) entries)+      YamlModel.NodeScalar v0 -> case v0 of+        YamlModel.ScalarBool v1 -> Right (JsonModel.ValueBoolean v1)+        YamlModel.ScalarDecimal v1 -> Right (JsonModel.ValueNumber v1)+        YamlModel.ScalarFloat v1 -> Right (JsonModel.ValueNumber (Literals.float64ToDecimal v1))+        YamlModel.ScalarInt v1 -> Right (JsonModel.ValueNumber (Literals.bigintToDecimal v1))+        YamlModel.ScalarNull -> Right JsonModel.ValueNull+        YamlModel.ScalarStr v1 -> Right (JsonModel.ValueString v1)+      YamlModel.NodeSequence v0 ->+        let results = Eithers.mapList (\n -> yamlToJson n) v0+        in (Eithers.map (\vs -> JsonModel.ValueArray vs) results)
+ src/main/haskell/Hydra/Json/Yaml/Encode.hs view
@@ -0,0 +1,48 @@+-- Note: this is an automatically generated file. Do not edit.+-- | JSON-to-YAML encoding. Converts JSON Values to YAML Nodes (always succeeds), and Hydra Terms to YAML Nodes via JSON.++module Hydra.Json.Yaml.Encode where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Encode as Encode+import qualified Hydra.Json.Model as JsonModel+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import qualified Hydra.Yaml.Model as YamlModel+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Convert a JSON value to a YAML node. Always succeeds since YAML is a superset of JSON.+jsonToYaml :: JsonModel.Value -> YamlModel.Node+jsonToYaml value =+    case value of+      JsonModel.ValueArray v0 -> YamlModel.NodeSequence (Lists.map (\v -> jsonToYaml v) v0)+      JsonModel.ValueBoolean v0 -> YamlModel.NodeScalar (YamlModel.ScalarBool v0)+      JsonModel.ValueNull -> YamlModel.NodeScalar YamlModel.ScalarNull+      JsonModel.ValueNumber v0 -> YamlModel.NodeScalar (YamlModel.ScalarDecimal v0)+      JsonModel.ValueObject v0 -> YamlModel.NodeMapping (Maps.fromList (Lists.map (\kv -> (YamlModel.NodeScalar (YamlModel.ScalarStr (Pairs.first kv)), (jsonToYaml (Pairs.second kv)))) v0))+      JsonModel.ValueString v0 -> YamlModel.NodeScalar (YamlModel.ScalarStr v0)+-- | Encode a Hydra term to a YAML node via JSON encoding.+toYaml :: M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> Core.Term -> Either String YamlModel.Node+toYaml types tname typ term = Eithers.map (\v -> jsonToYaml v) (Encode.toJson types tname typ term)
+ src/main/haskell/Hydra/Kernel.hs view
@@ -0,0 +1,112 @@+-- | A proxy for the Hydra kernel, i.e. the code which must be present in every Hydra implementation.+{-+Note: the following modules are part of the kernel, but they are not default imports because of name collisions:+- Hydra.Ast+- Hydra.Decode.Core+- Hydra.Encode.Core+- Hydra.Extract.Core+- Hydra.Extract.Util+- Hydra.Show.Variants+- Hydra.Codegen+- Hydra.Json.Parser+- Hydra.Json.Writer+- Hydra.Parsers+- Hydra.Show.Core+- Hydra.Topology+-}++module Hydra.Kernel (+  module Hydra.Paths,+  module Hydra.Adapt,+  module Hydra.Analysis,+  module Hydra.Annotations,+  module Hydra.Arity,+  module Hydra.Checking,+  module Hydra.Coders,+  module Hydra.Constants,+  module Hydra.Core,+  module Hydra.Dependencies,+  module Hydra.Environment,+  module Hydra.Error.Checking,+  module Hydra.Error.Core,+  module Hydra.Errors,+  module Hydra.Languages,+  module Hydra.Formatting,+  module Hydra.Graph,+  module Hydra.Inference,+  module Hydra.Lexical,+  module Hydra.Literals,+  module Hydra.Packaging,+  module Hydra.Parsing,+  module Hydra.Typed,+  module Hydra.Names,+  module Hydra.Predicates,+  module Hydra.Query,+  module Hydra.Reduction,+  module Hydra.Reflect,+  module Hydra.Relational,+  module Hydra.Resolution,+  module Hydra.Rewriting,+  module Hydra.Scoping,+  module Hydra.Serialization,+  module Hydra.Strip,+  module Hydra.Settings,+  module Hydra.Sorting,+  module Hydra.Substitution,+  module Hydra.Tabular,+  module Hydra.Templates,+  module Hydra.Testing,+  module Hydra.Typing,+  module Hydra.Unification,+  module Hydra.Util,+  module Hydra.Validation,+  module Hydra.Variables,+  module Hydra.Variants,+) where++import Hydra.Paths+import Hydra.Adapt+import Hydra.Analysis+import Hydra.Annotations+import Hydra.Arity+import Hydra.Checking+import Hydra.Coders+import Hydra.Constants+import Hydra.Core+import Hydra.Dependencies+import Hydra.Environment+import Hydra.Error.Checking+import Hydra.Error.Core+import Hydra.Errors+import Hydra.Languages+import Hydra.Formatting+import Hydra.Graph+import Hydra.Inference+import Hydra.Lexical+import Hydra.Literals+import Hydra.Packaging+import Hydra.Parsing+import Hydra.Typed+import Hydra.Names+import Hydra.Predicates+import Hydra.Query+import Hydra.Reduction+import Hydra.Reflect+import Hydra.Relational+import Hydra.Resolution+import Hydra.Rewriting+import Hydra.Scoping+import Hydra.Serialization+import Hydra.Settings+import Hydra.Strip+import Hydra.Sorting+import Hydra.Substitution+import Hydra.Tabular+import Hydra.Templates+import Hydra.Testing+import Hydra.Typing+import Hydra.Unification+import Hydra.Util+import Hydra.Validation+import Hydra.Variables+import Hydra.Variants
+ src/main/haskell/Hydra/Languages.hs view
@@ -0,0 +1,67 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Language constraints for Hydra Core++module Hydra.Languages where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Language constraints for Hydra Core, i.e. no constraints.+hydraLanguage :: Coders.Language+hydraLanguage =+    Coders.Language {+      Coders.languageName = (Coders.LanguageName "hydra.core"),+      Coders.languageConstraints = Coders.LanguageConstraints {+        Coders.languageConstraintsLiteralVariants = literalVariants,+        Coders.languageConstraintsFloatTypes = floatTypes,+        Coders.languageConstraintsIntegerTypes = integerTypes,+        Coders.languageConstraintsTermVariants = termVariants,+        Coders.languageConstraintsTypeVariants = typeVariants,+        Coders.languageConstraintsTypes = types},+      Coders.languageSupportedFeatures = (Sets.fromList [+        Coders.LanguageFeaturePartialApplication,+        Coders.LanguageFeatureNestedCaseStatements,+        Coders.LanguageFeatureNestedPolymorphicLetBindings]),+      Coders.languageCaseConventions = Coders.CaseConventions {+        Coders.caseConventionsConstant = Util.CaseConventionUpperSnake,+        Coders.caseConventionsDirectory = Util.CaseConventionPascal,+        Coders.caseConventionsEnumValue = Util.CaseConventionPascal,+        Coders.caseConventionsField = Util.CaseConventionCamel,+        Coders.caseConventionsFile = Util.CaseConventionPascal,+        Coders.caseConventionsModule = Util.CaseConventionLowerSnake,+        Coders.caseConventionsTerm = Util.CaseConventionCamel,+        Coders.caseConventionsTermVariable = Util.CaseConventionCamel,+        Coders.caseConventionsType = Util.CaseConventionPascal,+        Coders.caseConventionsTypeVariable = Util.CaseConventionCamel},+      Coders.languageDefaultFileExtension = (Util.FileExtension "")}+  where+    literalVariants = Sets.fromList Reflect.literalVariants+    floatTypes = Sets.fromList Reflect.floatTypes+    integerTypes = Sets.fromList Reflect.integerTypes+    termVariants = Sets.fromList Reflect.termVariants+    typeVariants = Sets.fromList Reflect.typeVariants+    types =+        \t -> case t of+          _ -> True
+ src/main/haskell/Hydra/Lexical.hs view
@@ -0,0 +1,272 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A module for lexical operations over graphs.++module Hydra.Lexical where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Build a Graph from element bindings, environment, and primitives+buildGraph :: [Core.Binding] -> M.Map Core.Name (Maybe Core.Term) -> M.Map Core.Name Graph.Primitive -> Graph.Graph+buildGraph elements environment primitives =++      let elementTerms = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) elements)+          letTerms =+                  Maps.fromList (Optionals.mapOptional (\kv -> Optionals.map (\t -> (Pairs.first kv, t)) (Pairs.second kv)) (Maps.toList environment))+          mergedTerms = Maps.union elementTerms letTerms+          filteredTerms = Maps.filterWithKey (\k -> \_v -> Logic.not (Maps.member k primitives)) mergedTerms+          elementTypes =+                  Maps.fromList (Optionals.cat (Lists.map (\b -> Optionals.map (\ts -> (Core.bindingName b, ts)) (Core.bindingTypeScheme b)) elements))+          filteredTypes = Maps.filterWithKey (\k -> \_v -> Logic.not (Maps.member k primitives)) elementTypes+      in Graph.Graph {+        Graph.graphBoundTerms = filteredTerms,+        Graph.graphBoundTypes = filteredTypes,+        Graph.graphClassConstraints = Maps.empty,+        Graph.graphLambdaVariables = (Sets.fromList (Maps.keys (Maps.filter (\mt -> Optionals.isNone mt) environment))),+        Graph.graphMetadata = Maps.empty,+        Graph.graphPrimitives = primitives,+        Graph.graphSchemaTypes = Maps.empty,+        Graph.graphTypeVariables = Sets.empty}+-- | Pick a name that does not collide with a reserved set, by appending a numeric suffix to the requested name when necessary+chooseUniqueName :: S.Set Core.Name -> Core.Name -> Core.Name+chooseUniqueName reserved name =++      let tryName =+              \index ->+                let candidate = Logic.ifElse (Equality.equal index 1) name (Core.Name (Strings.cat2 (Core.unName name) (Literals.showInt32 index)))+                in (Logic.ifElse (Sets.member candidate reserved) (tryName (Math.add index 1)) candidate)+      in (tryName 1)+-- | Resolve a schema type through a chain of zero or more typedefs+dereferenceSchemaType :: Core.Name -> M.Map Core.Name Core.TypeScheme -> Maybe Core.TypeScheme+dereferenceSchemaType name types =++      let forType =+              \t -> case t of+                Core.TypeAnnotated v0 -> forType (Core.annotatedTypeBody v0)+                Core.TypeForall v0 -> Optionals.map (\ts -> Core.TypeScheme {+                  Core.typeSchemeVariables = (Lists.cons (Core.forallTypeParameter v0) (Core.typeSchemeVariables ts)),+                  Core.typeSchemeBody = (Core.typeSchemeBody ts),+                  Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts)}) (forType (Core.forallTypeBody v0))+                Core.TypeVariable v0 -> dereferenceSchemaType v0 types+                _ -> Just (Core.TypeScheme {+                  Core.typeSchemeVariables = [],+                  Core.typeSchemeBody = t,+                  Core.typeSchemeConstraints = Nothing})+      in (Optionals.bind (Maps.lookup name types) (\ts -> Optionals.map (\ts2 -> Core.TypeScheme {+        Core.typeSchemeVariables = (Lists.concat2 (Core.typeSchemeVariables ts) (Core.typeSchemeVariables ts2)),+        Core.typeSchemeBody = (Core.typeSchemeBody ts2),+        Core.typeSchemeConstraints = (Core.typeSchemeConstraints ts2)}) (forType (Core.typeSchemeBody ts))))+-- | Look up a binding by name in a graph, returning Either an error or the binding+dereferenceVariable :: Graph.Graph -> Core.Name -> Either Errors.Error Core.Binding+dereferenceVariable graph name =+    Optionals.cases (lookupBinding graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+      Errors.noSuchBindingErrorName = name})))) (\right_ -> Right right_)+-- | Create a graph from a parent graph, schema types, and list of element bindings+elementsToGraph :: Graph.Graph -> M.Map Core.Name Core.TypeScheme -> [Core.Binding] -> Graph.Graph+elementsToGraph parent schemaTypes elements =++      let prims = Graph.graphPrimitives parent+          g = buildGraph elements Maps.empty prims+      in Graph.Graph {+        Graph.graphBoundTerms = (Graph.graphBoundTerms g),+        Graph.graphBoundTypes = (Graph.graphBoundTypes g),+        Graph.graphClassConstraints = (Graph.graphClassConstraints g),+        Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),+        Graph.graphMetadata = (Graph.graphMetadata g),+        Graph.graphPrimitives = (Graph.graphPrimitives g),+        Graph.graphSchemaTypes = schemaTypes,+        Graph.graphTypeVariables = (Graph.graphTypeVariables g)}+-- | An empty graph; no elements, no primitives, no schema.+emptyGraph :: Graph.Graph+emptyGraph =+    Graph.Graph {+      Graph.graphBoundTerms = Maps.empty,+      Graph.graphBoundTypes = Maps.empty,+      Graph.graphClassConstraints = Maps.empty,+      Graph.graphLambdaVariables = Sets.empty,+      Graph.graphMetadata = Maps.empty,+      Graph.graphPrimitives = Maps.empty,+      Graph.graphSchemaTypes = Maps.empty,+      Graph.graphTypeVariables = Sets.empty}+-- | An empty inference context; fresh-variable counter at zero and empty trace.+emptyInferenceContext :: Typing.InferenceContext+emptyInferenceContext =+    Typing.InferenceContext {+      Typing.inferenceContextFreshTypeVariableCount = 0,+      Typing.inferenceContextTrace = []}+-- | Extract the fields of a record or union type+fieldsOf :: Core.Type -> [Core.FieldType]+fieldsOf t =++      let stripped = Strip.deannotateType t+      in case stripped of+        Core.TypeForall v0 -> fieldsOf (Core.forallTypeBody v0)+        Core.TypeRecord v0 -> v0+        Core.TypeUnion v0 -> v0+        _ -> []+-- | Look up a field by name in a record's field map and decode its value, failing if the field is missing+getField :: M.Map Core.Name t0 -> Core.Name -> (t0 -> Either Errors.Error t1) -> Either Errors.Error t1+getField m fname decode =+    Optionals.cases (Maps.lookup fname m) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+      Errors.noMatchingFieldErrorFieldName = fname})))) decode+-- | Reconstruct a list of Bindings from a Graph's boundTerms and boundTypes+graphToBindings :: Graph.Graph -> [Core.Binding]+graphToBindings g =+    Lists.map (\p ->+      let name = Pairs.first p+          term = Pairs.second p+      in Core.Binding {+        Core.bindingName = name,+        Core.bindingTerm = term,+        Core.bindingTypeScheme = (Maps.lookup name (Graph.graphBoundTypes g))}) (Maps.toList (Graph.graphBoundTerms g))+-- | Build a graph with primitives assembled from built-in and user-provided lists. User-provided primitives shadow built-in ones.+graphWithPrimitives :: [Graph.Primitive] -> [Graph.Primitive] -> Graph.Graph+graphWithPrimitives builtIn userProvided =++      let toMap = \ps -> Maps.fromList (Lists.map (\p -> (Packaging.primitiveDefinitionName (Graph.primitiveDefinition p), p)) ps)+          prims = Maps.union (toMap userProvided) (toMap builtIn)+      in (buildGraph [] Maps.empty prims)+-- | Look up a binding in a graph by name+lookupBinding :: Graph.Graph -> Core.Name -> Maybe Core.Binding+lookupBinding graph name =+    Optionals.map (\term -> Core.Binding {+      Core.bindingName = name,+      Core.bindingTerm = term,+      Core.bindingTypeScheme = (Maps.lookup name (Graph.graphBoundTypes graph))}) (Maps.lookup name (Graph.graphBoundTerms graph))+-- | Look up a primitive function in a graph by name+lookupPrimitive :: Graph.Graph -> Core.Name -> Maybe Graph.Primitive+lookupPrimitive graph name = Maps.lookup name (Graph.graphPrimitives graph)+-- | Look up a term by name in a graph+lookupTerm :: Graph.Graph -> Core.Name -> Maybe Core.Term+lookupTerm graph name = Maps.lookup name (Graph.graphBoundTerms graph)+-- | Match a term against an enum type, dispatching on the variant name to a value from the supplied list+matchEnum :: Graph.Graph -> Core.Name -> [(Core.Name, t0)] -> Core.Term -> Either Errors.Error t0+matchEnum graph tname pairs =+    matchUnion graph tname (Lists.map (\pair -> matchUnitField (Pairs.first pair) (Pairs.second pair)) pairs)+-- | Match a term against a record type and decode its fields, failing if the term is not a record+matchRecord :: t0 -> (M.Map Core.Name Core.Term -> Either Errors.Error t1) -> Core.Term -> Either Errors.Error t1+matchRecord graph decode term =++      let stripped = Strip.deannotateAndDetypeTerm term+      in case stripped of+        Core.TermRecord v0 -> decode (Maps.fromList (Lists.map (\field -> (Core.fieldName field, (Core.fieldTerm field))) (Core.recordFields v0)))+        _ -> Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "record",+          Errors.unexpectedShapeErrorActual = (ShowCore.term term)})))+-- | Match a term against a union type, dispatching on the injected variant to the appropriate decoder. Variable terms are dereferenced through the graph before matching.+matchUnion :: Graph.Graph -> Core.Name -> [(Core.Name, (Core.Term -> Either Errors.Error t0))] -> Core.Term -> Either Errors.Error t0+matchUnion graph tname pairs term =++      let stripped = Strip.deannotateAndDetypeTerm term+          mapping = Maps.fromList pairs+      in case stripped of+        Core.TermVariable v0 -> Eithers.bind (requireBinding graph v0) (\el -> matchUnion graph tname pairs (Core.bindingTerm el))+        Core.TermInject v0 ->+          let exp =++                    let fname = Core.fieldName (Core.injectionField v0)+                        val = Core.fieldTerm (Core.injectionField v0)+                    in (Optionals.cases (Maps.lookup fname mapping) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                      Errors.noMatchingFieldErrorFieldName = fname})))) (\f -> f val))+          in (Logic.ifElse (Equality.equal (Core.unName (Core.injectionTypeName v0)) (Core.unName tname)) exp (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+            Errors.unexpectedShapeErrorExpected = (Strings.cat2 "injection for type " (Core.unName tname)),+            Errors.unexpectedShapeErrorActual = (ShowCore.term term)})))))+        _ -> Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = (Strings.cat2 "injection for type " (Core.unName tname)),+          Errors.unexpectedShapeErrorActual = (ShowCore.term stripped)})))+-- | Build a (fieldName, decoder) pair for a unit-valued union variant: the decoder ignores its argument and returns a fixed value+matchUnitField :: t0 -> t1 -> (t0, (t2 -> Either t3 t1))+matchUnitField fname x = (fname, (\ignored -> Right x))+-- | Look up a binding in a graph by name, failing with a list of available names if it is not found+requireBinding :: Graph.Graph -> Core.Name -> Either Errors.Error Core.Binding+requireBinding graph name =++      let showAll = False+          ellipsis =+                  \strings -> Logic.ifElse (Logic.and (Equality.gt (Lists.length strings) 3) (Logic.not showAll)) (Lists.concat2 (Lists.take 3 strings) [+                    "..."]) strings+          errMsg =+                  Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "no such element: " (Core.unName name)) ". Available elements: {") (Strings.intercalate ", " (ellipsis (Lists.map Core.unName (Maps.keys (Graph.graphBoundTerms graph)))))) "}"+      in (Optionals.cases (lookupBinding graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorOther (Errors.OtherResolutionError errMsg)))) (\x -> Right x))+-- | Look up a primitive in a graph by name, failing if it is not registered+requirePrimitive :: Graph.Graph -> Core.Name -> Either Errors.Error Graph.Primitive+requirePrimitive graph name =+    Optionals.cases (lookupPrimitive graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchPrimitive (Errors.NoSuchPrimitiveError {+      Errors.noSuchPrimitiveErrorName = name})))) (\x -> Right x)+-- | Look up a primitive's type scheme in a graph by name, failing if the primitive is not registered+requirePrimitiveType :: Graph.Graph -> Core.Name -> Either Errors.Error Core.TypeScheme+requirePrimitiveType tx name =++      let mts =+              Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives tx))+      in (Optionals.cases mts (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchPrimitive (Errors.NoSuchPrimitiveError {+        Errors.noSuchPrimitiveErrorName = name})))) (\ts -> Right ts))+-- | Resolve a name to a term in the graph, following variable references, and fail if the name is not bound+requireTerm :: Graph.Graph -> Core.Name -> Either Errors.Error Core.Term+requireTerm graph name =+    Optionals.cases (resolveTerm graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+      Errors.noSuchBindingErrorName = name})))) (\x -> Right x)+-- | TODO: distinguish between lambda-bound and let-bound variables+resolveTerm :: Graph.Graph -> Core.Name -> Maybe Core.Term+resolveTerm graph name =++      let recurse =+              \term ->+                let stripped = Strip.deannotateTerm term+                in case stripped of+                  Core.TermVariable v0 -> resolveTerm graph v0+                  _ -> Just term+      in (Optionals.cases (lookupTerm graph name) Nothing recurse)+-- | Strip annotations and type lambdas/applications from a term, then follow variable references through the graph until a non-variable term is reached+stripAndDereferenceTerm :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+stripAndDereferenceTerm graph term =++      let stripped = Strip.deannotateAndDetypeTerm term+      in case stripped of+        Core.TermVariable v0 -> Eithers.bind (requireTerm graph v0) (\t -> stripAndDereferenceTerm graph t)+        _ -> Right stripped+-- | Strip annotations and dereference variables, returning Either an error or the resolved term+stripAndDereferenceTermEither :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+stripAndDereferenceTermEither graph term =++      let stripped = Strip.deannotateAndDetypeTerm term+      in case stripped of+        Core.TermVariable v0 -> Eithers.either (\left_ -> Left left_) (\binding -> stripAndDereferenceTermEither graph (Core.bindingTerm binding)) (dereferenceVariable graph v0)+        _ -> Right stripped
+ src/main/haskell/Hydra/Lib/Chars.hs view
@@ -0,0 +1,189 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.chars module.++module Hydra.Lib.Chars where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+isAlphaNum :: Packaging.PrimitiveDefinition+isAlphaNum =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.isAlphaNum"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether a character is alphanumeric."),+        Packaging.entityMetadataComments = [+          "True if the argument is a Unicode letter or digit, false otherwise.",+          "The argument is interpreted as a Unicode code point: arguments outside the valid code-point range [0, 0x10FFFF] yield an implementation-defined result (typically false).",+          "The classification is based on Unicode general categories (any of L*, Nd, Nl, No).",+          "Total. Corresponds to Haskell's Data.Char.isAlphaNum :: Char -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+isLower :: Packaging.PrimitiveDefinition+isLower =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.isLower"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether a character is lowercase."),+        Packaging.entityMetadataComments = [+          "True if the argument is a Unicode lowercase letter (general category Ll), false otherwise.",+          "The argument is interpreted as a Unicode code point: arguments outside [0, 0x10FFFF] yield an implementation-defined result (typically false).",+          "Note that not every letter is classified as uppercase or lowercase (e.g. titlecase letters, modifier letters, and letters in scripts without a case distinction are neither).",+          "Total. Corresponds to Haskell's Data.Char.isLower :: Char -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+isSpace :: Packaging.PrimitiveDefinition+isSpace =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.isSpace"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether a character is a whitespace character."),+        Packaging.entityMetadataComments = [+          "True if the argument is a Unicode whitespace character, false otherwise.",+          "The whitespace set follows Haskell's Data.Char.isSpace, which recognises U+0020 (space), U+0009 (tab), U+000A (line feed), U+000B (vertical tab), U+000C (form feed), U+000D (carriage return), U+00A0 (no-break space), and other Unicode characters with general category Zs, Zl, or Zp.",+          "Total. Corresponds to Haskell's Data.Char.isSpace :: Char -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+isUpper :: Packaging.PrimitiveDefinition+isUpper =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.isUpper"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether a character is uppercase."),+        Packaging.entityMetadataComments = [+          "True if the argument is a Unicode uppercase letter (general category Lu), false otherwise.",+          "The argument is interpreted as a Unicode code point: arguments outside [0, 0x10FFFF] yield an implementation-defined result (typically false).",+          "Note that titlecase letters (Lt) are not classified as uppercase by this predicate.",+          "Total. Corresponds to Haskell's Data.Char.isUpper :: Char -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+toLower :: Packaging.PrimitiveDefinition+toLower =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.toLower"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a character to lowercase."),+        Packaging.entityMetadataComments = [+          "Return the simple (one-to-one) Unicode lowercase mapping of the argument, or the argument itself if it has no lowercase mapping.",+          "This is a code-point-to-code-point mapping, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not lowercase to \"ss\"; it returns itself).",+          "The argument is interpreted as a Unicode code point.",+          "Total. Corresponds to Haskell's Data.Char.toLower :: Char -> Char."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+toUpper :: Packaging.PrimitiveDefinition+toUpper =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.chars.toUpper"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a character to uppercase."),+        Packaging.entityMetadataComments = [+          "Return the simple (one-to-one) Unicode uppercase mapping of the argument, or the argument itself if it has no uppercase mapping.",+          "This is a code-point-to-code-point mapping, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not uppercase to \"SS\"; it returns itself).",+          "The argument is interpreted as a Unicode code point.",+          "Total. Corresponds to Haskell's Data.Char.toUpper :: Char -> Char."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Lib/Eithers.hs view
@@ -0,0 +1,1108 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.eithers module.++module Hydra.Lib.Eithers where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+bimap :: Packaging.PrimitiveDefinition+bimap =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.bimap"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map over both sides of an either value."),+        Packaging.entityMetadataComments = [+          "bimap(f, g, e) applies f to the contained value if e is a Left, or g if e is a Right; the result retains the same Left/Right variant.",+          "Total. Corresponds to Haskell's Data.Bifunctor.bimap :: (a -> c) -> (b -> d) -> Either a b -> Either c d."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "w"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "z"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "w"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "w"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "g"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "e"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "x"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermEither (Left (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))))}))})),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermEither (Right (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "g")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Map over both sides of an Either, defined in terms of either.")))]))})))}+bind :: Packaging.PrimitiveDefinition+bind =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.bind"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Bind (flatMap) for either: if Right, apply the function; if Left, return unchanged."),+        Packaging.entityMetadataComments = [+          "bind(e, f) is the monadic bind for either with a fixed Left type: if e is Right v, the result is f(v); if e is Left x, the result is Left x with the Left type preserved.",+          "Used to chain computations that may fail with a common error type.",+          "Total. Corresponds to Haskell's (>>=) :: Either a b -> (b -> Either a c) -> Either a c."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+              Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "z"))}))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "z"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "e"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "f"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "x"))))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Monadic bind for Either, defined in terms of either.")))]))})))}+either :: Packaging.PrimitiveDefinition+either =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.either"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Eliminate an either value by applying one of two functions."),+        Packaging.entityMetadataComments = [+          "either(f, g, e) returns f(x) if e is Left x and g(y) if e is Right y.",+          "The fundamental eliminator for the either type; every other primitive in this namespace can be derived from it.",+          "Total. Corresponds to Haskell's either :: (a -> c) -> (b -> c) -> Either a b -> c."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "z"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "z"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "z"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+foldl :: Packaging.PrimitiveDefinition+foldl =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.foldl"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Left-fold over a list with an Either-returning function, short-circuiting on Left."),+        Packaging.entityMetadataComments = [+          "foldl(f, acc0, xs) folds f over xs from the left, threading an accumulator of type a, where each application may fail with Left e: foldl iterates while f returns Right, propagates Left on the first failure, and returns Right (final accumulator) if all elements were processed. Equivalent to chaining bind over the list.",+          "Total in the sense that it terminates on finite inputs; the result is a Left whenever any application of f returns one.",+          "Corresponds to a short-circuiting variant of Haskell's foldM specialised to Either."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+                Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                  Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+                  Core.eitherTypeRight = (Core.TypeVariable (Core.Name "x"))}))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "y"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "x"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "acc0"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "xs"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "acc"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "el"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})),+                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "a"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "el"))}))}))}))}))}))})),+                  Core.applicationArgument = (Core.TermEither (Right (Core.TermVariable (Core.Name "acc0"))))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Either-short-circuiting left fold, defined in terms of bind.")))]))})))}+fromLeft :: Packaging.PrimitiveDefinition+fromLeft =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.fromLeft"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Extract the Left value, or return a default."),+        Packaging.entityMetadataComments = [+          "fromLeft(def, e) returns the contained Left value if e is a Left, or def if e is a Right.",+          "Total. Corresponds to Haskell's Data.Either.fromLeft :: a -> Either a b -> a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = True},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "x"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "def"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "e"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "_"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermVariable (Core.Name "def"))}))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Extract the Left value or return a default, defined in terms of either.")))]))})))}+fromRight :: Packaging.PrimitiveDefinition+fromRight =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.fromRight"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Extract the Right value, or return a default."),+        Packaging.entityMetadataComments = [+          "fromRight(def, e) returns the contained Right value if e is a Right, or def if e is a Left.",+          "Total. Corresponds to Haskell's Data.Either.fromRight :: b -> Either a b -> b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "y")),+            Typing.parameterIsLazy = True},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "y"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "def"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "e"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "_"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermVariable (Core.Name "def"))}))})),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "x"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Extract the Right value or return a default, defined in terms of either.")))]))})))}+isLeft :: Packaging.PrimitiveDefinition+isLeft =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.isLeft"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether an either is a Left value."),+        Packaging.entityMetadataComments = [+          "True if the argument is a Left variant, false if a Right.",+          "Total. Corresponds to Haskell's Data.Either.isLeft :: Either a b -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "e"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "_"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean True))}))})),+              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "_"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean False))}))})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Check whether an Either is a Left value, defined in terms of either.")))]))})))}+isRight :: Packaging.PrimitiveDefinition+isRight =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.isRight"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether an either is a Right value."),+        Packaging.entityMetadataComments = [+          "True if the argument is a Right variant, false if a Left.",+          "Total. Corresponds to Haskell's Data.Either.isRight :: Either a b -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "e"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "_"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean False))}))})),+              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "_"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean True))}))})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Check whether an Either is a Right value, defined in terms of either.")))]))})))}+lefts :: Packaging.PrimitiveDefinition+lefts =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.lefts"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Extract all Left values from a list of either values."),+        Packaging.entityMetadataComments = [+          "lefts(xs) returns a list containing every Left value in xs, in original order, with Right values discarded.",+          "Total. Corresponds to Haskell's Data.Either.lefts :: [Either a b] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "xs"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "e"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "acc"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "l"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "l"))})),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))})),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "_"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermVariable (Core.Name "acc"))}))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})),+              Core.applicationArgument = (Core.TermList [])})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Extract all Left values from a list of eithers, defined in terms of either + foldr.")))]))})))}+map :: Packaging.PrimitiveDefinition+map =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.map"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function over the Right side of an either (standard functor map)."),+        Packaging.entityMetadataComments = [+          "map(f, e) returns Right (f y) if e is Right y, or Left x unchanged if e is Left x.",+          "The functor instance for either; treats the Right variant as the focus and leaves the Left variant alone.",+          "Total. Corresponds to Haskell's fmap :: (a -> b) -> Either e a -> Either e b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "x"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "e"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "x"))))}))})),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "y"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermEither (Right (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))))}))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Map a function over the Right side, defined in terms of either.")))]))})))}+mapList :: Packaging.PrimitiveDefinition+mapList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.mapList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function returning either over a list, collecting results or short-circuiting on Left."),+        Packaging.entityMetadataComments = [+          "mapList(f, xs) applies f to each element of xs. If every application returns Right, the result is Right of the list of contained values, in original order. The first application that returns Left short-circuits the whole result to that Left.",+          "Total. Corresponds to Haskell's traverse :: (a -> Either e b) -> [a] -> Either e [b]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+            Core.eitherTypeRight = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "xs"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "x"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "acc"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "y"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "ys"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))}))})),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))}))})),+                Core.applicationArgument = (Core.TermEither (Right (Core.TermList [])))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Traverse a list with an Either-returning function, short-circuiting on Left.")))]))})))}+mapOptional :: Packaging.PrimitiveDefinition+mapOptional =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.mapOptional"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function returning either over an optional, or return Right none if none."),+        Packaging.entityMetadataComments = [+          "mapOptional(f, m) returns Right none if m is none; otherwise applies f to the contained value and returns the result with Right wrapped around given.",+          "Total. Corresponds to Haskell's traverse :: (a -> Either e b) -> Maybe a -> Either e (Maybe b)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+            Core.eitherTypeRight = (Core.TypeOptional (Core.TypeVariable (Core.Name "y")))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "m"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (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.TermVariable (Core.Name "m"))})),+                Core.applicationArgument = (Core.TermEither (Right (Core.TermOptional Nothing)))})),+              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "y"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermOptional (Just (Core.TermVariable (Core.Name "y"))))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Traverse an Optional with an Either-returning function.")))]))})))}+mapSet :: Packaging.PrimitiveDefinition+mapSet =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.mapSet"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function returning either over a set, collecting results or short-circuiting on Left."),+        Packaging.entityMetadataComments = [+          "mapSet(f, s) applies f to each element of s in unspecified order. If every application returns Right, the result is Right of the set of contained values (deduplicated by the result type's ordering); the first application returning Left short-circuits the whole result to that Left.",+          "Total. Corresponds to Haskell's traverse-style operation specialised to Set."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "z")),+            Core.eitherTypeRight = (Core.TypeSet (Core.TypeVariable (Core.Name "y")))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "s"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "ys"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.fromList")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))}))})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "x"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "acc"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})),+                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "y"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "ys"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "ys"))}))}))})),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))}))})),+                  Core.applicationArgument = (Core.TermEither (Right (Core.TermList [])))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Traverse a Set with an Either-returning function, defined via list+set conversion.")))]))})))}+partitionEithers :: Packaging.PrimitiveDefinition+partitionEithers =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.partitionEithers"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Partition a list of either values into lefts and rights."),+        Packaging.entityMetadataComments = [+          "partitionEithers(xs) returns a pair (lefts, rights) where lefts contains every Left value from xs in original order and rights contains every Right value from xs in original order.",+          "Total. Corresponds to Haskell's Data.Either.partitionEithers :: [Either a b] -> ([a], [b])."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypePair (Core.PairType {+            Core.pairTypeFirst = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Core.pairTypeSecond = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "xs"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "e"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "acc"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "l"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermPair (+                              Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "l"))})),+                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}),+                              (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))))}))})),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "r"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermPair (+                            Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}),+                            (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "r"))})),+                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))))}))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})),+              Core.applicationArgument = (Core.TermPair (Core.TermList [], (Core.TermList [])))})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Partition a list of eithers into (lefts, rights), defined in terms of either + foldr.")))]))})))}+rights :: Packaging.PrimitiveDefinition+rights =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.eithers.rights"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Extract all Right values from a list of either values."),+        Packaging.entityMetadataComments = [+          "rights(xs) returns a list containing every Right value in xs, in original order, with Left values discarded.",+          "Total. Corresponds to Haskell's Data.Either.rights :: [Either a b] -> [b]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeEither (Core.EitherType {+              Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "x")),+              Core.eitherTypeRight = (Core.TypeVariable (Core.Name "y"))}))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "xs"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "e"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "acc"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "_"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermVariable (Core.Name "acc"))}))})),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "r"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "r"))})),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}))}))})),+              Core.applicationArgument = (Core.TermList [])})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Extract all Right values from a list of eithers, defined in terms of either + foldr.")))]))})))}
+ src/main/haskell/Hydra/Lib/Equality.hs view
@@ -0,0 +1,387 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.equality module.++module Hydra.Lib.Equality where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+compare :: Packaging.PrimitiveDefinition+compare =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.compare"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compare two values and return a Comparison."),+        Packaging.entityMetadataComments = [+          "compare(x, y) returns the hydra.util.Comparison value that classifies the relationship between x and y under the type's ordering: LessThan if x < y, EqualTo if x == y, GreaterThan if x > y.",+          "The result type's three-valued tag is the canonical primitive comparison; the boolean comparators (lt/lte/gt/gte) and equal are derivable from it.",+          "Requires an 'ordering' type-class constraint on the argument type, which is the closest Hydra equivalent to Haskell's Ord instance.",+          "Total. Corresponds to Haskell's compare :: Ord a => a -> a -> Ordering."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "hydra.util.Comparison"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+equal :: Packaging.PrimitiveDefinition+equal =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.equal"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether two values are equal."),+        Packaging.entityMetadataComments = [+          "equal(x, y) returns true if x and y are structurally equal under the type's notion of equality.",+          "Requires an 'equality' type-class constraint on the argument type, which is the closest Hydra equivalent to Haskell's Eq instance.",+          "Equality is reflexive, symmetric, and transitive (no NaN-style exception on floating-point: floating-point equality is provided per the underlying host's IEEE 754 comparison rules, so NaN /= NaN at the level of float64/float32).",+          "Total. Corresponds to Haskell's (==) :: Eq a => a -> a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "equality")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+gt :: Packaging.PrimitiveDefinition+gt =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.gt"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether the first value is greater than the second."),+        Packaging.entityMetadataComments = [+          "gt(x, y) returns true iff x > y under the type's ordering.",+          "Requires an 'ordering' constraint on the argument type.",+          "Total. Corresponds to Haskell's (>) :: Ord a => a -> a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+gte :: Packaging.PrimitiveDefinition+gte =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.gte"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether the first value is greater than or equal to the second."),+        Packaging.entityMetadataComments = [+          "gte(x, y) returns true iff x >= y under the type's ordering.",+          "Requires an 'ordering' constraint on the argument type.",+          "Total. Corresponds to Haskell's (>=) :: Ord a => a -> a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+identity :: Packaging.PrimitiveDefinition+identity =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.identity"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return a value unchanged."),+        Packaging.entityMetadataComments = [+          "identity(x) = x. The polymorphic identity function.",+          "Total. Corresponds to Haskell's id :: a -> a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "x"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermVariable (Core.Name "x"))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Return a value unchanged.")))]))})))}+lt :: Packaging.PrimitiveDefinition+lt =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.lt"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether the first value is less than the second."),+        Packaging.entityMetadataComments = [+          "lt(x, y) returns true iff x < y under the type's ordering.",+          "Requires an 'ordering' constraint on the argument type.",+          "Total. Corresponds to Haskell's (<) :: Ord a => a -> a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+lte :: Packaging.PrimitiveDefinition+lte =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.lte"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether the first value is less than or equal to the second."),+        Packaging.entityMetadataComments = [+          "lte(x, y) returns true iff x <= y under the type's ordering.",+          "Requires an 'ordering' constraint on the argument type.",+          "Total. Corresponds to Haskell's (<=) :: Ord a => a -> a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+max :: Packaging.PrimitiveDefinition+max =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.max"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the maximum of two values."),+        Packaging.entityMetadataComments = [+          "max(x, y) returns the larger of x and y under the type's ordering; if x == y, it returns y (matching Haskell's convention).",+          "Requires an 'ordering' constraint on the argument type.",+          "Total. Corresponds to Haskell's max :: Ord a => a -> a -> a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "x"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "y"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.gte")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Return the maximum of two values, defined in terms of gte and ifElse.")))]))})))}+min :: Packaging.PrimitiveDefinition+min =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.equality.min"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the minimum of two values."),+        Packaging.entityMetadataComments = [+          "min(x, y) returns the smaller of x and y under the type's ordering; if x == y, it returns x (matching Haskell's convention).",+          "Requires an 'ordering' constraint on the argument type.",+          "Total. Corresponds to Haskell's min :: Ord a => a -> a -> a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "x"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "y"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.lte")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Return the minimum of two values, defined in terms of lte and ifElse.")))]))})))}
+ src/main/haskell/Hydra/Lib/Lists.hs view
@@ -0,0 +1,1268 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.lists module.++module Hydra.Lib.Lists where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+apply :: Packaging.PrimitiveDefinition+apply =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.apply"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Apply a list of functions to a list of values (applicative style)."),+        Packaging.entityMetadataComments = [+          "apply(fs, xs) returns the list of all f x for f in fs and x in xs, in order: for each f in fs (outer loop), for each x in xs (inner loop).",+          "Equivalent to the applicative list instance.",+          "Total. Corresponds to Haskell's (<*>) :: [a -> b] -> [a] -> [b]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))}))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bind :: Packaging.PrimitiveDefinition+bind =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.bind"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Apply a function that returns lists to each element and flatten the results."),+        Packaging.entityMetadataComments = [+          "bind(xs, f) applies f to each element of xs and concatenates the resulting lists in order. Equivalent to concatMap.",+          "Total. Corresponds to Haskell's (>>=) :: [a] -> (a -> [b]) -> [b]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeList (Core.TypeVariable (Core.Name "y")))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+concat :: Packaging.PrimitiveDefinition+concat =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.concat"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Concatenate a list of lists."),+        Packaging.entityMetadataComments = [+          "concat(xss) returns the list obtained by appending all the lists in xss in order.",+          "Total. Corresponds to Haskell's concat :: [[a]] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeList (Core.TypeVariable (Core.Name "x")))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+concat2 :: Packaging.PrimitiveDefinition+concat2 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.concat2"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Concatenate two lists."),+        Packaging.entityMetadataComments = [+          "concat2(xs, ys) returns xs with ys appended.",+          "Total. Corresponds to Haskell's (++) :: [a] -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+cons :: Packaging.PrimitiveDefinition+cons =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.cons"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Prepend a value to a list."),+        Packaging.entityMetadataComments = [+          "cons(x, xs) returns a list whose head is x and whose tail is xs.",+          "Total. Corresponds to Haskell's (:) :: a -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+drop :: Packaging.PrimitiveDefinition+drop =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.drop"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Drop the first n elements from a list."),+        Packaging.entityMetadataComments = [+          "drop(n, xs) returns the suffix of xs after dropping the first n elements; if n is greater than or equal to length(xs) the result is the empty list; if n is non-positive the result is xs unchanged.",+          "Total. Corresponds to Haskell's drop :: Int -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+dropWhile :: Packaging.PrimitiveDefinition+dropWhile =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.dropWhile"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Drop elements from the beginning of a list while the predicate is true."),+        Packaging.entityMetadataComments = [+          "dropWhile(p, xs) returns the suffix of xs starting at the first element for which p returns false. If p is true for every element, the result is the empty list.",+          "Total. Corresponds to Haskell's dropWhile :: (a -> Bool) -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+elem :: Packaging.PrimitiveDefinition+elem =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.elem"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether an element is in a list."),+        Packaging.entityMetadataComments = [+          "elem(x, xs) returns true iff some element of xs is equal to x.",+          "Requires an 'equality' constraint on the element type.",+          "Total. Corresponds to Haskell's elem :: Eq a => a -> [a] -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "equality")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+filter :: Packaging.PrimitiveDefinition+filter =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.filter"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Filter a list by a predicate."),+        Packaging.entityMetadataComments = [+          "filter(p, xs) returns the list of elements x in xs for which p(x) is true, in original order.",+          "Total. Corresponds to Haskell's filter :: (a -> Bool) -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+find :: Packaging.PrimitiveDefinition+find =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.find"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Find the first element matching a predicate."),+        Packaging.entityMetadataComments = [+          "find(p, xs) returns Just(x) where x is the first element of xs for which p(x) is true, or Nothing if no such element exists.",+          "Total. Corresponds to Haskell's find :: (a -> Bool) -> [a] -> Maybe a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+foldl :: Packaging.PrimitiveDefinition+foldl =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.foldl"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Left-fold a list with an accumulator."),+        Packaging.entityMetadataComments = [+          "foldl(f, acc0, xs) reduces xs left-associatively: foldl(f, acc0, [x1, x2, ..., xn]) = f(f(f(acc0, x1), x2), ..., xn). For the empty list the result is acc0.",+          "Strict in the accumulator on hosts where laziness would otherwise leak space.",+          "Total on finite inputs. Corresponds to Haskell's foldl' :: (b -> a -> b) -> b -> [a] -> b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+                Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "y")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "y"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+foldr :: Packaging.PrimitiveDefinition+foldr =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.foldr"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Right-fold a list with an accumulator."),+        Packaging.entityMetadataComments = [+          "foldr(f, acc0, xs) reduces xs right-associatively: foldr(f, acc0, [x1, ..., xn]) = f(x1, f(x2, ..., f(xn, acc0))). For the empty list the result is acc0.",+          "Total on finite inputs. Corresponds to Haskell's foldr :: (a -> b -> b) -> b -> [a] -> b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+                Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "y")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "y"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+group :: Packaging.PrimitiveDefinition+group =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.group"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Group consecutive equal elements."),+        Packaging.entityMetadataComments = [+          "group(xs) returns a list of lists obtained by grouping consecutive equal elements of xs together. Each inner list is non-empty and contains equal elements; the concatenation of the result equals xs.",+          "Equality is determined by the element type's 'equality' constraint.",+          "Total. Corresponds to Haskell's Data.List.group :: Eq a => [a] -> [[a]]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "equality")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeList (Core.TypeVariable (Core.Name "x"))))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+intercalate :: Packaging.PrimitiveDefinition+intercalate =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.intercalate"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Intercalate a list of lists with a separator list between each."),+        Packaging.entityMetadataComments = [+          "intercalate(sep, xss) returns the concatenation of xss with sep inserted between consecutive lists. Equivalent to concat(intersperse(sep, xss)).",+          "Total. Corresponds to Haskell's intercalate :: [a] -> [[a]] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeList (Core.TypeVariable (Core.Name "x")))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+intersperse :: Packaging.PrimitiveDefinition+intersperse =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.intersperse"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Intersperse a value between consecutive elements of a list."),+        Packaging.entityMetadataComments = [+          "intersperse(sep, xs) returns xs with sep inserted between each pair of adjacent elements; for lists of length 0 or 1 the input is returned unchanged.",+          "Total. Corresponds to Haskell's intersperse :: a -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+length :: Packaging.PrimitiveDefinition+length =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.length"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the length of a list."),+        Packaging.entityMetadataComments = [+          "length(xs) returns the number of elements in xs as an int32. Returns 0 for the empty list.",+          "Total on finite inputs; the int32 result overflows for lists longer than 2^31-1 elements.",+          "Corresponds to Haskell's length :: [a] -> Int (with narrowing to Int32)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+map :: Packaging.PrimitiveDefinition+map =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.map"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function over a list."),+        Packaging.entityMetadataComments = [+          "map(f, xs) returns the list of f(x) for each x in xs, in original order.",+          "Total. Corresponds to Haskell's map :: (a -> b) -> [a] -> [b] / fmap on lists."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeAt :: Packaging.PrimitiveDefinition+maybeAt =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.maybeAt"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the element at the given index, or Nothing if out of bounds."),+        Packaging.entityMetadataComments = [+          "maybeAt(i, xs) returns Just(xs[i]) if 0 <= i < length(xs), or Nothing otherwise.",+          "Total. Wraps the Haskell (!!) operator, which is partial, in maybe to make out-of-bounds total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeHead :: Packaging.PrimitiveDefinition+maybeHead =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.maybeHead"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the first element, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "maybeHead(xs) returns Just(x) where x is the first element of xs, or Nothing if xs is empty.",+          "Total. Wraps Haskell's partial head in maybe."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeInit :: Packaging.PrimitiveDefinition+maybeInit =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.maybeInit"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return all elements except the last, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "maybeInit(xs) returns Just(ys) where ys is xs with its last element removed, or Nothing if xs is empty.",+          "Total. Wraps Haskell's partial init in maybe."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeList (Core.TypeVariable (Core.Name "x"))))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeLast :: Packaging.PrimitiveDefinition+maybeLast =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.maybeLast"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the last element, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "maybeLast(xs) returns Just(x) where x is the last element of xs, or Nothing if xs is empty.",+          "Total. Wraps Haskell's partial last in maybe."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeTail :: Packaging.PrimitiveDefinition+maybeTail =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.maybeTail"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return all elements except the first, or Nothing if the list is empty."),+        Packaging.entityMetadataComments = [+          "maybeTail(xs) returns Just(ys) where ys is xs with its first element removed, or Nothing if xs is empty.",+          "Total. Wraps Haskell's partial tail in maybe."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeList (Core.TypeVariable (Core.Name "x"))))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+nub :: Packaging.PrimitiveDefinition+nub =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.nub"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Remove duplicate elements from a list."),+        Packaging.entityMetadataComments = [+          "nub(xs) returns the list of distinct elements of xs, in the order of their first occurrence.",+          "Requires an 'equality' constraint on the element type.",+          "Quadratic in the length of xs in the worst case.",+          "Total. Corresponds to Haskell's Data.List.nub :: Eq a => [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "equality")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+null :: Packaging.PrimitiveDefinition+null =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.null"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether a list is empty."),+        Packaging.entityMetadataComments = [+          "null(xs) returns true iff xs is the empty list.",+          "Total. Corresponds to Haskell's null :: [a] -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+partition :: Packaging.PrimitiveDefinition+partition =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.partition"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Partition a list into elements that satisfy a predicate and those that do not."),+        Packaging.entityMetadataComments = [+          "partition(p, xs) returns a pair (yes, no) where yes is the list of elements of xs for which p is true and no is the list of elements for which p is false, each preserving original order.",+          "Total. Corresponds to Haskell's partition :: (a -> Bool) -> [a] -> ([a], [a])."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypePair (Core.PairType {+            Core.pairTypeFirst = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Core.pairTypeSecond = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+pure :: Packaging.PrimitiveDefinition+pure =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.pure"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Wrap a value in a single-element list."),+        Packaging.entityMetadataComments = [+          "pure(x) = [x]. The applicative pure for lists.",+          "Total. Corresponds to Haskell's pure :: a -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+replicate :: Packaging.PrimitiveDefinition+replicate =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.replicate"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Build a list of n copies of a value."),+        Packaging.entityMetadataComments = [+          "replicate(n, x) returns a list of n copies of x; for n <= 0 the result is the empty list.",+          "Total. Corresponds to Haskell's replicate :: Int -> a -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+reverse :: Packaging.PrimitiveDefinition+reverse =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.reverse"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Reverse a list."),+        Packaging.entityMetadataComments = [+          "reverse(xs) returns the elements of xs in reverse order.",+          "Total. Corresponds to Haskell's reverse :: [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+singleton :: Packaging.PrimitiveDefinition+singleton =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.singleton"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Construct a single-element list."),+        Packaging.entityMetadataComments = [+          "singleton(x) = [x]. Identical to pure for lists.",+          "Total. Corresponds to Haskell's singleton :: a -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+sort :: Packaging.PrimitiveDefinition+sort =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.sort"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Sort a list."),+        Packaging.entityMetadataComments = [+          "sort(xs) returns xs sorted in ascending order under the element type's ordering. Sort is stable: equal elements preserve their original relative order.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.List.sort :: Ord a => [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+sortOn :: Packaging.PrimitiveDefinition+sortOn =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.sortOn"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Sort a list using a key-extraction function."),+        Packaging.entityMetadataComments = [+          "sortOn(f, xs) returns xs sorted in ascending order by f(x) for each element x. Sort is stable: elements with equal keys preserve their original relative order.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.List.sortOn :: Ord b => (a -> b) -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+span :: Packaging.PrimitiveDefinition+span =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.span"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Split a list at the first element where the predicate fails."),+        Packaging.entityMetadataComments = [+          "span(p, xs) returns a pair (ys, zs) where ys is the longest prefix of xs whose elements all satisfy p, and zs is the remainder of xs starting at the first element that fails p (or zs is empty if all elements satisfy p).",+          "Total. Corresponds to Haskell's span :: (a -> Bool) -> [a] -> ([a], [a])."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypePair (Core.PairType {+            Core.pairTypeFirst = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Core.pairTypeSecond = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+take :: Packaging.PrimitiveDefinition+take =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.take"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Take the first n elements of a list."),+        Packaging.entityMetadataComments = [+          "take(n, xs) returns the prefix of xs of length min(n, length(xs)); if n is non-positive the result is the empty list.",+          "Total. Corresponds to Haskell's take :: Int -> [a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+transpose :: Packaging.PrimitiveDefinition+transpose =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.transpose"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Transpose a list of lists."),+        Packaging.entityMetadataComments = [+          "transpose(xss) returns a list of lists where the i-th inner list contains the i-th element of every inner list of xss that has at least i+1 elements. Inner lists of differing lengths produce a ragged result rather than an error.",+          "Total. Corresponds to Haskell's Data.List.transpose :: [[a]] -> [[a]]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeList (Core.TypeVariable (Core.Name "x")))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeList (Core.TypeVariable (Core.Name "x"))))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+uncons :: Packaging.PrimitiveDefinition+uncons =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.uncons"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Decompose a list into its head and tail, or Nothing if empty."),+        Packaging.entityMetadataComments = [+          "uncons(xs) returns Just(head, tail) where head is the first element of xs and tail is the remaining list, or Nothing if xs is empty.",+          "Total. Corresponds to Haskell's Data.List.uncons :: [a] -> Maybe (a, [a])."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypePair (Core.PairType {+            Core.pairTypeFirst = (Core.TypeVariable (Core.Name "x")),+            Core.pairTypeSecond = (Core.TypeList (Core.TypeVariable (Core.Name "x")))})))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+zip :: Packaging.PrimitiveDefinition+zip =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.zip"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Zip two lists element-wise into pairs."),+        Packaging.entityMetadataComments = [+          "zip(xs, ys) returns the list of pairs (xs[i], ys[i]) for i from 0 to min(length(xs), length(ys))-1. The result has length equal to the shorter of the two inputs.",+          "Total. Corresponds to Haskell's zip :: [a] -> [b] -> [(a, b)]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "y"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypePair (Core.PairType {+            Core.pairTypeFirst = (Core.TypeVariable (Core.Name "x")),+            Core.pairTypeSecond = (Core.TypeVariable (Core.Name "y"))})))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+zipWith :: Packaging.PrimitiveDefinition+zipWith =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.lists.zipWith"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Zip two lists with a combining function."),+        Packaging.entityMetadataComments = [+          "zipWith(f, xs, ys) returns the list of f(xs[i], ys[i]) for i from 0 to min(length(xs), length(ys))-1. The result has length equal to the shorter of the two inputs.",+          "Total. Corresponds to Haskell's zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+                Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "z"))}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "y"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "z")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Lib/Literals.hs view
@@ -0,0 +1,1409 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.literals module.++module Hydra.Lib.Literals where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+bigintToDecimal :: Packaging.PrimitiveDefinition+bigintToDecimal =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToDecimal"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to a decimal."),+        Packaging.entityMetadataComments = [+          "bigintToDecimal(x) returns the exact decimal representation of x. Since decimal is arbitrary-precision and bigint is also arbitrary-precision, the conversion is lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeDecimal)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToInt16 :: Packaging.PrimitiveDefinition+bigintToInt16 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToInt16"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to an int16 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToInt16(x) returns x reduced modulo 2^16 and reinterpreted as a signed two's-complement int16. Values outside [-2^15, 2^15-1] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt16))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToInt32 :: Packaging.PrimitiveDefinition+bigintToInt32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToInt32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to an int32 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToInt32(x) returns x reduced modulo 2^32 and reinterpreted as a signed two's-complement int32. Values outside [-2^31, 2^31-1] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToInt64 :: Packaging.PrimitiveDefinition+bigintToInt64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToInt64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to an int64 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToInt64(x) returns x reduced modulo 2^64 and reinterpreted as a signed two's-complement int64. Values outside [-2^63, 2^63-1] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToInt8 :: Packaging.PrimitiveDefinition+bigintToInt8 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToInt8"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to an int8 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToInt8(x) returns x reduced modulo 2^8 and reinterpreted as a signed two's-complement int8. Values outside [-128, 127] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt8))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToUint16 :: Packaging.PrimitiveDefinition+bigintToUint16 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToUint16"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to a uint16 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToUint16(x) returns x reduced modulo 2^16 as an unsigned uint16. Values outside [0, 2^16-1] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint16))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToUint32 :: Packaging.PrimitiveDefinition+bigintToUint32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToUint32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to a uint32 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToUint32(x) returns x reduced modulo 2^32 as an unsigned uint32. Values outside [0, 2^32-1] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToUint64 :: Packaging.PrimitiveDefinition+bigintToUint64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToUint64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to a uint64 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToUint64(x) returns x reduced modulo 2^64 as an unsigned uint64. Values outside [0, 2^64-1] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+bigintToUint8 :: Packaging.PrimitiveDefinition+bigintToUint8 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.bigintToUint8"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a bigint to a uint8 (truncating)."),+        Packaging.entityMetadataComments = [+          "bigintToUint8(x) returns x reduced modulo 2^8 as an unsigned uint8. Values outside [0, 255] wrap silently with no exception.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint8))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+binaryToBytes :: Packaging.PrimitiveDefinition+binaryToBytes =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.binaryToBytes"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert binary data to a list of byte values."),+        Packaging.entityMetadataComments = [+          "binaryToBytes(b) returns the bytes of b as an int32 list with values in [0, 255], preserving byte order.",+          "The result list element type is int32 rather than uint8 because Hydra's primitive collections work most naturally with int32 indices.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBinary),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+binaryToString :: Packaging.PrimitiveDefinition+binaryToString =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.binaryToString"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert binary data to a UTF-8 string."),+        Packaging.entityMetadataComments = [+          "binaryToString(b) interprets the bytes of b as a UTF-8-encoded string and returns the decoded value.",+          "The behavior on invalid UTF-8 byte sequences is host-defined: most hosts substitute the replacement character U+FFFD; some may signal an error or truncate.",+          "Total in the sense that it does not raise from the kernel's perspective, but the result may carry the host's replacement semantics."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBinary),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+decimalToBigint :: Packaging.PrimitiveDefinition+decimalToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.decimalToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a decimal to a bigint (truncating)."),+        Packaging.entityMetadataComments = [+          "decimalToBigint(x) returns x truncated toward zero. Fractional parts are discarded.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeDecimal),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+decimalToFloat32 :: Packaging.PrimitiveDefinition+decimalToFloat32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.decimalToFloat32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a decimal to a float32."),+        Packaging.entityMetadataComments = [+          "decimalToFloat32(x) returns the IEEE 754 binary32 value closest to x under roundTiesToEven. Values outside the float32 representable range overflow to \177\8734. Subnormal precision loss is silent.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeDecimal),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+decimalToFloat64 :: Packaging.PrimitiveDefinition+decimalToFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.decimalToFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a decimal to a float64."),+        Packaging.entityMetadataComments = [+          "decimalToFloat64(x) returns the IEEE 754 binary64 value closest to x under roundTiesToEven. Values outside the float64 representable range overflow to \177\8734. Subnormal precision loss is silent.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeDecimal),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+float32ToDecimal :: Packaging.PrimitiveDefinition+float32ToDecimal =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.float32ToDecimal"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a float32 to a decimal."),+        Packaging.entityMetadataComments = [+          "float32ToDecimal(x) returns the exact decimal representation of the binary32 value x. Special float32 values (\177\8734, NaN) have a host-defined decimal representation; finite values convert exactly since binary32 values are dyadic rationals.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeDecimal)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+float32ToFloat64 :: Packaging.PrimitiveDefinition+float32ToFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.float32ToFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a float32 to a float64."),+        Packaging.entityMetadataComments = [+          "float32ToFloat64(x) returns the binary64 value with the same numeric value as x; \177\8734 and NaN pass through. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+float64ToDecimal :: Packaging.PrimitiveDefinition+float64ToDecimal =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.float64ToDecimal"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a float64 to a decimal."),+        Packaging.entityMetadataComments = [+          "float64ToDecimal(x) returns the exact decimal representation of the binary64 value x. Special float64 values (\177\8734, NaN) have a host-defined decimal representation; finite values convert exactly since binary64 values are dyadic rationals.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeDecimal)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+float64ToFloat32 :: Packaging.PrimitiveDefinition+float64ToFloat32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.float64ToFloat32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a float64 to a float32 (lossy)."),+        Packaging.entityMetadataComments = [+          "float64ToFloat32(x) returns the binary32 value closest to x under roundTiesToEven. Values outside the binary32 range overflow to \177\8734; subnormal precision loss is silent; NaN payload may be canonicalized by the host.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+int16ToBigint :: Packaging.PrimitiveDefinition+int16ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.int16ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert an int16 to a bigint."),+        Packaging.entityMetadataComments = [+          "int16ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt16)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+int32ToBigint :: Packaging.PrimitiveDefinition+int32ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.int32ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert an int32 to a bigint."),+        Packaging.entityMetadataComments = [+          "int32ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+int64ToBigint :: Packaging.PrimitiveDefinition+int64ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.int64ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert an int64 to a bigint."),+        Packaging.entityMetadataComments = [+          "int64ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+int8ToBigint :: Packaging.PrimitiveDefinition+int8ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.int8ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert an int8 to a bigint."),+        Packaging.entityMetadataComments = [+          "int8ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt8)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readBigint :: Packaging.PrimitiveDefinition+readBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a bigint."),+        Packaging.entityMetadataComments = [+          "readBigint(s) returns Just(x) where x is the bigint parsed from s, or Nothing if s is not a valid bigint literal.",+          "Accepted syntax follows the Haskell Show/Read convention: an optional leading minus sign followed by a sequence of decimal digits. Whitespace is not stripped; leading or trailing whitespace causes parse failure.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readBoolean :: Packaging.PrimitiveDefinition+readBoolean =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readBoolean"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a boolean."),+        Packaging.entityMetadataComments = [+          "readBoolean(s) returns Just(true) for \"true\", Just(false) for \"false\", and Nothing for any other input (including \"True\"/\"False\" with capital initial letter on some hosts; behavior on capitalized forms is host-defined and should not be relied upon).",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeBoolean))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readDecimal :: Packaging.PrimitiveDefinition+readDecimal =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readDecimal"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a decimal."),+        Packaging.entityMetadataComments = [+          "readDecimal(s) returns Just(x) where x is the decimal parsed from s, or Nothing on parse failure.",+          "Accepted syntax is the standard decimal literal: an optional sign, an integer part, an optional fractional part, and an optional exponent (e.g. -1.5, 2e10, 0.0).",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeDecimal))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readFloat32 :: Packaging.PrimitiveDefinition+readFloat32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readFloat32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a float32."),+        Packaging.entityMetadataComments = [+          "readFloat32(s) returns Just(x) where x is the IEEE 754 binary32 value closest to the number parsed from s under roundTiesToEven, or Nothing on parse failure.",+          "Accepted special-value literals (\"NaN\", \"Infinity\", \"-Infinity\", etc.) and their capitalization are host-defined.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readFloat64 :: Packaging.PrimitiveDefinition+readFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a float64."),+        Packaging.entityMetadataComments = [+          "readFloat64(s) returns Just(x) where x is the IEEE 754 binary64 value closest to the number parsed from s under roundTiesToEven, or Nothing on parse failure.",+          "Accepted special-value literals (\"NaN\", \"Infinity\", \"-Infinity\", etc.) and their capitalization are host-defined.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readInt16 :: Packaging.PrimitiveDefinition+readInt16 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readInt16"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as an int16."),+        Packaging.entityMetadataComments = [+          "readInt16(s) returns Just(x) where x is the int16 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-2^15, 2^15-1].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt16)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readInt32 :: Packaging.PrimitiveDefinition+readInt32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readInt32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as an int32."),+        Packaging.entityMetadataComments = [+          "readInt32(s) returns Just(x) where x is the int32 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-2^31, 2^31-1].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readInt64 :: Packaging.PrimitiveDefinition+readInt64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readInt64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as an int64."),+        Packaging.entityMetadataComments = [+          "readInt64(s) returns Just(x) where x is the int64 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-2^63, 2^63-1].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt64)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readInt8 :: Packaging.PrimitiveDefinition+readInt8 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readInt8"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as an int8."),+        Packaging.entityMetadataComments = [+          "readInt8(s) returns Just(x) where x is the int8 parsed from s, or Nothing if s is not a valid integer literal or the parsed value is outside [-128, 127].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt8)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readString :: Packaging.PrimitiveDefinition+readString =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readString"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string-literal token to a plain string (Just) or Nothing on parse failure."),+        Packaging.entityMetadataComments = [+          "readString(s) parses s as a Haskell-syntax string literal token: an opening double-quote, escaped characters per the Haskell lexical grammar (backslash escapes for special characters and Unicode code points), and a closing double-quote. Returns Just of the decoded payload on success or Nothing on malformed input.",+          "Total. The inverse of showString."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeString))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readUint16 :: Packaging.PrimitiveDefinition+readUint16 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readUint16"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a uint16."),+        Packaging.entityMetadataComments = [+          "readUint16(s) returns Just(x) where x is the uint16 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 2^16-1].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint16)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readUint32 :: Packaging.PrimitiveDefinition+readUint32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readUint32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a uint32."),+        Packaging.entityMetadataComments = [+          "readUint32(s) returns Just(x) where x is the uint32 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 2^32-1].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readUint64 :: Packaging.PrimitiveDefinition+readUint64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readUint64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a uint64."),+        Packaging.entityMetadataComments = [+          "readUint64(s) returns Just(x) where x is the uint64 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 2^64-1].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint64)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+readUint8 :: Packaging.PrimitiveDefinition+readUint8 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.readUint8"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Parse a string as a uint8."),+        Packaging.entityMetadataComments = [+          "readUint8(s) returns Just(x) where x is the uint8 parsed from s, or Nothing if s is not a valid non-negative integer literal or the parsed value is outside [0, 255].",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint8)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showBigint :: Packaging.PrimitiveDefinition+showBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a bigint as a string."),+        Packaging.entityMetadataComments = [+          "showBigint(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits. No leading zeros are produced (except for the value 0 itself, which renders as \"0\").",+          "Total. The inverse of readBigint."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showBoolean :: Packaging.PrimitiveDefinition+showBoolean =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showBoolean"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a boolean as a string."),+        Packaging.entityMetadataComments = [+          "showBoolean(true) = \"true\"; showBoolean(false) = \"false\".",+          "Total. The inverse of readBoolean."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showDecimal :: Packaging.PrimitiveDefinition+showDecimal =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showDecimal"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a decimal as a string."),+        Packaging.entityMetadataComments = [+          "showDecimal(x) returns the canonical decimal representation of x as a string. The exact form (use of scientific notation, trailing zeros, etc.) is host-defined but always round-trips with readDecimal.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeDecimal),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showFloat32 :: Packaging.PrimitiveDefinition+showFloat32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showFloat32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a float32 as a string."),+        Packaging.entityMetadataComments = [+          "showFloat32(x) returns a string representation of x. Finite values use the shortest decimal that round-trips through readFloat32 back to x. Special values render as \"NaN\", \"Infinity\", or \"-Infinity\" (capitalization is host-defined).",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showFloat64 :: Packaging.PrimitiveDefinition+showFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a float64 as a string."),+        Packaging.entityMetadataComments = [+          "showFloat64(x) returns a string representation of x. Finite values use the shortest decimal that round-trips through readFloat64 back to x. Special values render as \"NaN\", \"Infinity\", or \"-Infinity\" (capitalization is host-defined).",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showInt16 :: Packaging.PrimitiveDefinition+showInt16 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showInt16"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render an int16 as a string."),+        Packaging.entityMetadataComments = [+          "showInt16(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",+          "Total. The inverse of readInt16."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt16)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showInt32 :: Packaging.PrimitiveDefinition+showInt32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showInt32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render an int32 as a string."),+        Packaging.entityMetadataComments = [+          "showInt32(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",+          "Total. The inverse of readInt32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showInt64 :: Packaging.PrimitiveDefinition+showInt64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showInt64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render an int64 as a string."),+        Packaging.entityMetadataComments = [+          "showInt64(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",+          "Total. The inverse of readInt64."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showInt8 :: Packaging.PrimitiveDefinition+showInt8 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showInt8"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render an int8 as a string."),+        Packaging.entityMetadataComments = [+          "showInt8(x) returns the canonical decimal representation of x: an optional leading minus sign followed by decimal digits.",+          "Total. The inverse of readInt8."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt8)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showString :: Packaging.PrimitiveDefinition+showString =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showString"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a string as a string-literal token (escaped and quoted)."),+        Packaging.entityMetadataComments = [+          "showString(s) returns a Haskell-syntax string literal token representing s: an opening double-quote, the characters of s with special characters escaped (backslash sequences for control characters, quotes, and non-printable Unicode code points), and a closing double-quote.",+          "Total. The inverse of readString."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showUint16 :: Packaging.PrimitiveDefinition+showUint16 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showUint16"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a uint16 as a string."),+        Packaging.entityMetadataComments = [+          "showUint16(x) returns the canonical decimal representation of x.",+          "Total. The inverse of readUint16."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint16)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showUint32 :: Packaging.PrimitiveDefinition+showUint32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showUint32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a uint32 as a string."),+        Packaging.entityMetadataComments = [+          "showUint32(x) returns the canonical decimal representation of x.",+          "Total. The inverse of readUint32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showUint64 :: Packaging.PrimitiveDefinition+showUint64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showUint64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a uint64 as a string."),+        Packaging.entityMetadataComments = [+          "showUint64(x) returns the canonical decimal representation of x.",+          "Total. The inverse of readUint64."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+showUint8 :: Packaging.PrimitiveDefinition+showUint8 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.showUint8"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Render a uint8 as a string."),+        Packaging.entityMetadataComments = [+          "showUint8(x) returns the canonical decimal representation of x.",+          "Total. The inverse of readUint8."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint8)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+stringToBinary :: Packaging.PrimitiveDefinition+stringToBinary =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.stringToBinary"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a UTF-8 string to binary data."),+        Packaging.entityMetadataComments = [+          "stringToBinary(s) encodes s as a UTF-8 byte sequence and returns the result as binary data.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBinary)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+uint16ToBigint :: Packaging.PrimitiveDefinition+uint16ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.uint16ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a uint16 to a bigint."),+        Packaging.entityMetadataComments = [+          "uint16ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint16)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+uint32ToBigint :: Packaging.PrimitiveDefinition+uint32ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.uint32ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a uint32 to a bigint."),+        Packaging.entityMetadataComments = [+          "uint32ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+uint64ToBigint :: Packaging.PrimitiveDefinition+uint64ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.uint64ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a uint64 to a bigint."),+        Packaging.entityMetadataComments = [+          "uint64ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+uint8ToBigint :: Packaging.PrimitiveDefinition+uint8ToBigint =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.literals.uint8ToBigint"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a uint8 to a bigint."),+        Packaging.entityMetadataComments = [+          "uint8ToBigint(x) returns the bigint with the same numeric value as x. The conversion is exact and lossless.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeUint8)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeBigint))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Lib/Logic.hs view
@@ -0,0 +1,203 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.logic module.++module Hydra.Lib.Logic where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+and :: Packaging.PrimitiveDefinition+and =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.logic.and"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the logical AND of two boolean values."),+        Packaging.entityMetadataComments = [+          "and(p, q) returns true iff both p and q are true.",+          "Evaluation is strict in both arguments at the primitive level; for short-circuiting behavior, use ifElse.",+          "Total. Corresponds to Haskell's (&&) :: Bool -> Bool -> Bool (but without short-circuit evaluation)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "a"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "b"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "b"))})),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Logical AND, defined in terms of ifElse.")))]))})))}+ifElse :: Packaging.PrimitiveDefinition+ifElse =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.logic.ifElse"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute a conditional expression."),+        Packaging.entityMetadataComments = [+          "ifElse(p, t, f) returns t if p is true, or f if p is false.",+          "The unselected branch is not necessarily evaluated; ifElse is the standard way to express short-circuiting boolean logic and branching in Hydra.",+          "Total. Corresponds to Haskell's if/then/else."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = True},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = True}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "x"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+not :: Packaging.PrimitiveDefinition+not =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.logic.not"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the logical NOT of a boolean value."),+        Packaging.entityMetadataComments = [+          "not(p) returns false if p is true, or true if p is false.",+          "Total. Corresponds to Haskell's not :: Bool -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "a"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})),+            Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Logical NOT, defined in terms of ifElse.")))]))})))}+or :: Packaging.PrimitiveDefinition+or =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.logic.or"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the logical OR of two boolean values."),+        Packaging.entityMetadataComments = [+          "or(p, q) returns true iff at least one of p and q is true.",+          "Evaluation is strict in both arguments at the primitive level; for short-circuiting behavior, use ifElse.",+          "Total. Corresponds to Haskell's (||) :: Bool -> Bool -> Bool (but without short-circuit evaluation)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "a"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "b"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "b"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Logical OR, defined in terms of ifElse.")))]))})))}
+ src/main/haskell/Hydra/Lib/Maps.hs view
@@ -0,0 +1,1077 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.maps module.++module Hydra.Lib.Maps where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+alter :: Packaging.PrimitiveDefinition+alter =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.alter"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Alter a value at a key using a function which sees the optional current value."),+        Packaging.entityMetadataComments = [+          "alter(f, k, m) applies f to Just(v) when m contains key k with value v, or to Nothing when k is absent. If f returns Just(v'), the binding (k, v') is set in the result; if f returns Nothing, k is removed from the result.",+          "A single primitive that subsumes insert, delete, and adjust.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.alter :: Ord k => (Maybe v -> Maybe v) -> k -> Map k v -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeOptional (Core.TypeVariable (Core.Name "v"))),+              Core.functionTypeCodomain = (Core.TypeOptional (Core.TypeVariable (Core.Name "v")))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "k")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "k"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "m"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (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.TermVariable (Core.Name "f")),+                      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 "k"))})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.delete")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "k"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))})),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "vNew"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.insert")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "k"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "vNew"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "alter, defined in terms of lookup/insert/delete via optionals.cases.")))]))})))}+bimap :: Packaging.PrimitiveDefinition+bimap =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.bimap"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map functions over both the keys and values of a map."),+        Packaging.entityMetadataComments = [+          "bimap(fk, fv, m) returns a new map with key fk(k) and value fv(v) for each binding (k, v) in m.",+          "Key collisions after applying fk are resolved by keeping the last binding encountered (host may differ on collision policy if fk is not injective).",+          "Requires 'ordering' constraints on both the input and output key types.",+          "Total. Corresponds to a key-and-value lift of Haskell's Data.Map.fromList . map (\\(k,v) -> (fk k, fv v)) . toList."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k1"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k2"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v1"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v2"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "k1")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "k2"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v1")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "v2"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k1")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v1"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k2")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v2"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "fk"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "fv"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "m"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "p"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermPair (+                        Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "fk")),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}),+                        (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "fv")),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}))))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "bimap on a map, defined via toList/fromList.")))]))})))}+delete :: Packaging.PrimitiveDefinition+delete =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.delete"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Remove a key from a map."),+        Packaging.entityMetadataComments = [+          "delete(k, m) returns m with the binding for k removed; if k is not present, m is returned unchanged.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.delete :: Ord k => k -> Map k v -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "k")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+elems :: Packaging.PrimitiveDefinition+elems =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.elems"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the values of a map (in key order)."),+        Packaging.entityMetadataComments = [+          "elems(m) returns the values of m as a list, ordered by their keys' ascending order.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.elems :: Map k v -> [v]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "v")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+empty :: Packaging.PrimitiveDefinition+empty =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.empty"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The empty map."),+        Packaging.entityMetadataComments = [+          "empty is the map with no bindings.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.empty :: Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+filter :: Packaging.PrimitiveDefinition+filter =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.filter"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Filter a map by value."),+        Packaging.entityMetadataComments = [+          "filter(p, m) returns the submap of m containing exactly the bindings (k, v) for which p(v) is true.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.filter :: (v -> Bool) -> Map k v -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")),+              Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "p"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "m"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.filter")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "pr"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "p")),+                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "pr"))}))}))}))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "filter on a map, defined via toList/fromList.")))]))})))}+filterWithKey :: Packaging.PrimitiveDefinition+filterWithKey =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.filterWithKey"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Filter a map by key and value."),+        Packaging.entityMetadataComments = [+          "filterWithKey(p, m) returns the submap of m containing exactly the bindings (k, v) for which p(k, v) is true.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.filterWithKey :: (k -> v -> Bool) -> Map k v -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "k")),+              Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")),+                Core.functionTypeCodomain = (Core.TypeLiteral Core.LiteralTypeBoolean)}))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "p"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "m"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.filter")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "pr"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "p")),+                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "pr"))}))})),+                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "pr"))}))}))}))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "filterWithKey on a map, defined via toList/fromList.")))]))})))}+findWithDefault :: Packaging.PrimitiveDefinition+findWithDefault =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.findWithDefault"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Look up a value with a default if the key is absent."),+        Packaging.entityMetadataComments = [+          "findWithDefault(def, k, m) returns the value bound to k in m if k is present, or def otherwise. Equivalent to maybe(def, identity, lookup(k, m)).",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.findWithDefault :: Ord k => v -> k -> Map k v -> v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "v")),+            Typing.parameterIsLazy = True},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "k")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "v"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "def"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "k"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "m"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.fromOptional")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "def"))})),+                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 "k"))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "findWithDefault, defined in terms of lookup + fromOptional.")))]))})))}+fromList :: Packaging.PrimitiveDefinition+fromList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.fromList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Build a map from a list of key-value pairs."),+        Packaging.entityMetadataComments = [+          "fromList(xs) returns the map containing exactly the bindings in xs. If xs contains multiple entries for the same key, the last one wins (matching Haskell's fromList behavior).",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.fromList :: Ord k => [(k, v)] -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypePair (Core.PairType {+              Core.pairTypeFirst = (Core.TypeVariable (Core.Name "k")),+              Core.pairTypeSecond = (Core.TypeVariable (Core.Name "v"))}))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+insert :: Packaging.PrimitiveDefinition+insert =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.insert"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Insert a key-value pair into a map."),+        Packaging.entityMetadataComments = [+          "insert(k, v, m) returns m with the binding (k, v) added or updated. If k is already present, its value is overwritten.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.insert :: Ord k => k -> v -> Map k v -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "k")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "v")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+keys :: Packaging.PrimitiveDefinition+keys =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.keys"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the keys of a map (in key order)."),+        Packaging.entityMetadataComments = [+          "keys(m) returns the keys of m as a list, in ascending order.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.keys :: Map k v -> [k]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "k")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+lookup :: Packaging.PrimitiveDefinition+lookup =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.lookup"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Look up a value in a map by key, returning Nothing if absent."),+        Packaging.entityMetadataComments = [+          "lookup(k, m) returns Just(v) where v is the value bound to k in m, or Nothing if k is not present.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.lookup :: Ord k => k -> Map k v -> Maybe v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "k")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "v")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+map :: Packaging.PrimitiveDefinition+map =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.map"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function over the values of a map."),+        Packaging.entityMetadataComments = [+          "map(f, m) returns a map with the same keys as m and value f(v) for each binding (k, v).",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.map :: (v -> w) -> Map k v -> Map k w / fmap on Map."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v1"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v2"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v1")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "v2"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v1"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v2"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "m"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "p"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermPair (+                      Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}),+                      (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}))))}))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "map over values, defined via toList/fromList.")))]))})))}+mapKeys :: Packaging.PrimitiveDefinition+mapKeys =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.mapKeys"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function over the keys of a map."),+        Packaging.entityMetadataComments = [+          "mapKeys(f, m) returns a map where each binding (k, v) becomes (f(k), v). If f maps multiple keys to the same image, key collisions are resolved by keeping the binding with the greater original key (matching Haskell's mapKeys behavior).",+          "Requires 'ordering' constraints on both the input and output key types.",+          "Total. Corresponds to Haskell's Data.Map.mapKeys :: (Ord k1, Ord k2) => (k1 -> k2) -> Map k1 v -> Map k2 v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k1"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k2"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "k1")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "k2"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k1")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k2")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "m"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "p"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermPair (+                      Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}),+                      (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))))}))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.toList")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "map over keys, defined via toList/fromList.")))]))})))}+member :: Packaging.PrimitiveDefinition+member =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.member"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether a key is present in a map."),+        Packaging.entityMetadataComments = [+          "member(k, m) returns true iff k is a key in m.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.member :: Ord k => k -> Map k v -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "k")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+null :: Packaging.PrimitiveDefinition+null =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.null"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether a map is empty."),+        Packaging.entityMetadataComments = [+          "null(m) returns true iff m has no bindings.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.null :: Map k v -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+singleton :: Packaging.PrimitiveDefinition+singleton =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.singleton"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Construct a map with a single key-value pair."),+        Packaging.entityMetadataComments = [+          "singleton(k, v) returns the map containing exactly the binding (k, v).",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.singleton :: k -> v -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "k")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "v")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+size :: Packaging.PrimitiveDefinition+size =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.size"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the number of key-value pairs in a map."),+        Packaging.entityMetadataComments = [+          "size(m) returns the number of bindings in m as an int32.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.size :: Map k v -> Int (with narrowing to int32)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+toList :: Packaging.PrimitiveDefinition+toList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.toList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a map to a list of key-value pairs (in key order)."),+        Packaging.entityMetadataComments = [+          "toList(m) returns the bindings of m as a list of (key, value) pairs, in ascending key order.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.toList :: Map k v -> [(k, v)]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypePair (Core.PairType {+            Core.pairTypeFirst = (Core.TypeVariable (Core.Name "k")),+            Core.pairTypeSecond = (Core.TypeVariable (Core.Name "v"))})))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+union :: Packaging.PrimitiveDefinition+union =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.maps.union"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the union of two maps; the first map's bindings take precedence on key collision."),+        Packaging.entityMetadataComments = [+          "union(m1, m2) returns the map containing all bindings from m1 plus the bindings of m2 whose keys are not in m1. On key collision, the binding from m1 is preferred.",+          "Requires an 'ordering' constraint on the key type.",+          "Total. Corresponds to Haskell's Data.Map.union :: Ord k => Map k v -> Map k v -> Map k v."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "k"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "v"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeMap (Core.MapType {+              Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+              Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeMap (Core.MapType {+            Core.mapTypeKeys = (Core.TypeVariable (Core.Name "k")),+            Core.mapTypeValues = (Core.TypeVariable (Core.Name "v"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Lib/Math.hs view
@@ -0,0 +1,1310 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.math module.++module Hydra.Lib.Math where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+abs :: Packaging.PrimitiveDefinition+abs =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.abs"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The absolute value of an integer."),+        Packaging.entityMetadataComments = [+          "Absolute value of a signed 32-bit two's-complement integer. For non-negative inputs the result equals the input; for negative inputs the result is the arithmetic negation.",+          "The function is total but not injective at the boundary: abs(minBound) = minBound (i.e. abs(-2147483648) = -2147483648), because +2147483648 is not representable in int32.",+          "Corresponds to Haskell's abs :: Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+acos :: Packaging.PrimitiveDefinition+acos =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.acos"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The arc cosine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Principal value of the inverse cosine, in radians. The result is in [0, \960].",+          "For arguments outside the domain [-1, +1] (including \177\8734), the result is NaN. acos(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 acos operation and to Haskell's acos :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+acosh :: Packaging.PrimitiveDefinition+acosh =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.acosh"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The hyperbolic arc cosine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Principal value of the inverse hyperbolic cosine. The result is in [0, +\8734).",+          "For arguments less than 1 the result is NaN; acosh(1) = +0; acosh(+\8734) = +\8734; acosh(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 acosh operation and to Haskell's acosh :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+add :: Packaging.PrimitiveDefinition+add =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.add"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Integer addition."),+        Packaging.entityMetadataComments = [+          "Two's-complement 32-bit signed integer addition. The result is x + y reduced modulo 2^32 and reinterpreted as a signed int32 (i.e. arithmetic wraps silently on overflow, with no exception raised).",+          "The operation is total. Corresponds to Haskell's (+) :: Int32 -> Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+addFloat64 :: Packaging.PrimitiveDefinition+addFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.addFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Floating-point addition."),+        Packaging.entityMetadataComments = [+          "IEEE 754 binary64 addition. The result is the value of x + y rounded to the nearest representable float64 under the roundTiesToEven rounding-direction attribute.",+          "Adding infinities of opposite sign (+\8734 + -\8734 or -\8734 + +\8734) produces a NaN; adding any value to NaN produces a NaN. The sum of two zeros is +0, except (-0) + (-0) = -0.",+          "The operation is total: it never raises, but it may produce NaN. Corresponds to the IEEE 754 \2677.4.1 addition operation and to Haskell's (+) :: Double -> Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+asin :: Packaging.PrimitiveDefinition+asin =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.asin"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The arc sine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Principal value of the inverse sine, in radians. The result is in [-\960/2, +\960/2].",+          "For arguments outside the domain [-1, +1] (including \177\8734), the result is NaN; asin(\2832) = \2832; asin(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 asin operation and to Haskell's asin :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+asinh :: Packaging.PrimitiveDefinition+asinh =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.asinh"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The hyperbolic arc sine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Principal value of the inverse hyperbolic sine. Defined for all finite reals; asinh(\2832) = \2832; asinh(\177\8734) = \177\8734; asinh(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 asinh operation and to Haskell's asinh :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+atan :: Packaging.PrimitiveDefinition+atan =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.atan"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The arc tangent of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Principal value of the inverse tangent, in radians. The result is in (-\960/2, +\960/2); atan(\2832) = \2832; atan(\177\8734) = \177\960/2; atan(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 atan operation and to Haskell's atan :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+atan2 :: Packaging.PrimitiveDefinition+atan2 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.atan2"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The two-argument arc tangent (atan2)."),+        Packaging.entityMetadataComments = [+          "atan2(y, x) returns the angle in radians, in (-\960, +\960], from the positive x-axis to the point (x, y), using the signs of both arguments to determine the quadrant.",+          "Special cases follow IEEE 754 \2681.2: atan2(\2832, +x>0) = \2832; atan2(\2832, -x<0) = \177\960; atan2(\177y>0, 0) = \177\960/2; atan2(\177y, +\8734) = \2832; atan2(\177y, -\8734) = \177\960; atan2(\177\8734, finite) = \177\960/2; atan2(\177\8734, +\8734) = \177\960/4; atan2(\177\8734, -\8734) = \2835\960/4; atan2 of any NaN argument is NaN.",+          "Corresponds to Haskell's atan2 :: Double -> Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+atanh :: Packaging.PrimitiveDefinition+atanh =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.atanh"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The hyperbolic arc tangent of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Principal value of the inverse hyperbolic tangent. Defined for arguments in (-1, +1); atanh(\2833) = \177\8734 (with division-by-zero exception in IEEE 754); arguments outside [-1, +1] produce NaN; atanh(\2832) = \2832; atanh(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 atanh operation and to Haskell's atanh :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ceiling :: Packaging.PrimitiveDefinition+ceiling =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.ceiling"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The smallest integer greater than or equal to the argument, as a float."),+        Packaging.entityMetadataComments = [+          "The smallest integer value not less than the argument, returned as a float64. Equivalent to IEEE 754 \2677.3.1 roundToIntegralTowardPositive: ceiling(\2832) = \2832; ceiling(\177\8734) = \177\8734; ceiling(NaN) is NaN; the sign of a negative result is preserved when rounding to zero (e.g. ceiling(-0.5) = -0).",+          "Note that the return type is float64, not an integer type, so the result can exceed the integer range.",+          "Corresponds to Haskell's fromIntegral . ceiling :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+cos :: Packaging.PrimitiveDefinition+cos =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.cos"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The cosine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Cosine of an angle in radians, correctly rounded for finite arguments. The result is in [-1, +1]; cos(\2832) = 1; cos(\177\8734) is NaN (with invalid-operation exception in IEEE 754); cos(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 cos operation and to Haskell's cos :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+cosh :: Packaging.PrimitiveDefinition+cosh =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.cosh"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The hyperbolic cosine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Hyperbolic cosine. The result is in [1, +\8734]; cosh(\2832) = 1; cosh(\177\8734) = +\8734; cosh(NaN) is NaN. Large-magnitude arguments overflow to +\8734.",+          "Corresponds to the IEEE 754 \2681.2 cosh operation and to Haskell's cosh :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+e :: Packaging.PrimitiveDefinition+e =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.e"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Euler's constant (the base of the natural logarithm)."),+        Packaging.entityMetadataComments = [+          "The mathematical constant e \8776 2.718281828459045, the base of the natural logarithm, as the nearest representable float64. Equal to exp(1).",+          "Corresponds to Haskell's exp 1 :: Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+even :: Packaging.PrimitiveDefinition+even =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.even"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether an integer is even."),+        Packaging.entityMetadataComments = [+          "True if the argument is divisible by 2 (i.e. x mod 2 = 0), false otherwise.",+          "Total on all int32 inputs including negative numbers and minBound. Corresponds to Haskell's even :: Int32 -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.equality.equal")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.fromOptional")),+                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 0)))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.maybeMod")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),+                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 2)))}))}))})),+            Core.applicationArgument = (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 0)))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Test whether an integer is even, defined via maybeMod and equality.")))]))})))}+exp :: Packaging.PrimitiveDefinition+exp =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.exp"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The exponential function."),+        Packaging.entityMetadataComments = [+          "The exponential function: exp(x) = e^x. exp(\2832) = 1; exp(-\8734) = +0; exp(+\8734) = +\8734; exp(NaN) is NaN. Large positive arguments overflow to +\8734; large negative arguments underflow to +0.",+          "Corresponds to the IEEE 754 \2681.2 exp operation and to Haskell's exp :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+floor :: Packaging.PrimitiveDefinition+floor =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.floor"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The largest integer less than or equal to the argument, as a float."),+        Packaging.entityMetadataComments = [+          "The largest integer value not greater than the argument, returned as a float64. Equivalent to IEEE 754 \2677.3.1 roundToIntegralTowardNegative: floor(\2832) = \2832; floor(\177\8734) = \177\8734; floor(NaN) is NaN.",+          "Note that the return type is float64, not an integer type, so the result can exceed the integer range.",+          "Corresponds to Haskell's fromIntegral . floor :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+log :: Packaging.PrimitiveDefinition+log =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.log"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The natural logarithm."),+        Packaging.entityMetadataComments = [+          "The natural (base-e) logarithm. log(1) = +0; log(+0) = log(-0) = -\8734 (with division-by-zero exception in IEEE 754); log(x) for x < 0 is NaN (with invalid-operation exception); log(+\8734) = +\8734; log(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 log operation and to Haskell's log :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+logBase :: Packaging.PrimitiveDefinition+logBase =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.logBase"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Logarithm of the second argument in the base of the first."),+        Packaging.entityMetadataComments = [+          "logBase(b, x) computes the logarithm of x in base b, equivalent to log(x) / log(b).",+          "Inherits the special-case behavior of log for each argument (NaN propagation, sign of zeros, division by zero on log of a zero, NaN on negative arguments).",+          "Corresponds to Haskell's logBase :: Double -> Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+max :: Packaging.PrimitiveDefinition+max =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.max"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The maximum of two integers."),+        Packaging.entityMetadataComments = [+          "Return the larger of two int32 values under the usual signed-integer total order.",+          "Total on all inputs. Corresponds to Haskell's max :: Int32 -> Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeDiv :: Packaging.PrimitiveDefinition+maybeDiv =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.maybeDiv"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Integer division, or Nothing if dividing by zero."),+        Packaging.entityMetadataComments = [+          "Total integer division: maybeDiv(x, y) returns Just(x divided by y, rounded toward negative infinity) when y is non-zero, and Nothing when y = 0.",+          "The division rounds toward negative infinity (floor), so for example maybeDiv(-7, 2) = Just(-4).",+          "The boundary case maybeDiv(minBound, -1), whose mathematical result +2147483648 is not representable in int32, wraps to minBound (the two's-complement overflow).",+          "Corresponds to Haskell's div :: Int32 -> Int32 -> Int32, wrapped in maybe to make the zero-divisor case total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeMod :: Packaging.PrimitiveDefinition+maybeMod =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.maybeMod"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Integer modulus, or Nothing if dividing by zero."),+        Packaging.entityMetadataComments = [+          "Total integer modulus: maybeMod(x, y) returns Just(x mod y) when y is non-zero, and Nothing when y = 0.",+          "The result satisfies the identity x = (maybeDiv(x, y) result) * y + (maybeMod(x, y) result), so the sign of the result matches the sign of y (Knuth-style floor division). For example maybeMod(-7, 2) = Just(1).",+          "Corresponds to Haskell's mod :: Int32 -> Int32 -> Int32, wrapped in maybe to make the zero-divisor case total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybePred :: Packaging.PrimitiveDefinition+maybePred =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.maybePred"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The predecessor of an integer, or Nothing on underflow."),+        Packaging.entityMetadataComments = [+          "maybePred(x) returns Just(x - 1) when x > minBound, and Nothing when x = minBound (i.e. -2147483648). The function is total and does not wrap.",+          "Corresponds to Haskell's pred :: Int32 -> Int32, wrapped in maybe to make the boundary case total (Haskell's pred is a partial function that raises an error on minBound)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeRem :: Packaging.PrimitiveDefinition+maybeRem =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.maybeRem"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Integer remainder, or Nothing if dividing by zero."),+        Packaging.entityMetadataComments = [+          "Total integer remainder: maybeRem(x, y) returns Just(x rem y) when y is non-zero, and Nothing when y = 0.",+          "The result satisfies x = (truncate(x / y)) * y + (maybeRem(x, y) result), so the sign of the result matches the sign of x (truncated division, C-style remainder). For example maybeRem(-7, 2) = Just(-1).",+          "The boundary case maybeRem(minBound, -1) is 0 (no overflow, since the quotient overflow is absorbed).",+          "Corresponds to Haskell's rem :: Int32 -> Int32 -> Int32, wrapped in maybe to make the zero-divisor case total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeSucc :: Packaging.PrimitiveDefinition+maybeSucc =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.maybeSucc"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The successor of an integer, or Nothing on overflow."),+        Packaging.entityMetadataComments = [+          "maybeSucc(x) returns Just(x + 1) when x < maxBound, and Nothing when x = maxBound (i.e. 2147483647). The function is total and does not wrap.",+          "Corresponds to Haskell's succ :: Int32 -> Int32, wrapped in maybe to make the boundary case total (Haskell's succ is a partial function that raises an error on maxBound)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+min :: Packaging.PrimitiveDefinition+min =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.min"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The minimum of two integers."),+        Packaging.entityMetadataComments = [+          "Return the smaller of two int32 values under the usual signed-integer total order.",+          "Total on all inputs. Corresponds to Haskell's min :: Int32 -> Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+mul :: Packaging.PrimitiveDefinition+mul =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.mul"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Integer multiplication."),+        Packaging.entityMetadataComments = [+          "Two's-complement 32-bit signed integer multiplication. The result is x * y reduced modulo 2^32 and reinterpreted as a signed int32 (i.e. arithmetic wraps silently on overflow, with no exception raised).",+          "The operation is total. Corresponds to Haskell's (*) :: Int32 -> Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+mulFloat64 :: Packaging.PrimitiveDefinition+mulFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.mulFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Floating-point multiplication."),+        Packaging.entityMetadataComments = [+          "IEEE 754 binary64 multiplication. The result is the value of x * y rounded to the nearest representable float64 under the roundTiesToEven rounding-direction attribute.",+          "Multiplying 0 by \177\8734 (in either order) produces a NaN (with invalid-operation exception in IEEE 754); multiplying any value by NaN produces a NaN. The result's sign is the XOR of the operand signs (\2832 * \2832 = \2832 accordingly).",+          "The operation is total: it never raises, but it may produce NaN or \177\8734. Corresponds to the IEEE 754 \2677.4.1 multiplication operation and to Haskell's (*) :: Double -> Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+negate :: Packaging.PrimitiveDefinition+negate =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.negate"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Negate an integer."),+        Packaging.entityMetadataComments = [+          "Arithmetic negation of a 32-bit signed integer. The result is 0 - x reduced modulo 2^32 and reinterpreted as a signed int32.",+          "The function is total but not injective at the boundary: negate(minBound) = minBound (i.e. negate(-2147483648) = -2147483648), because +2147483648 is not representable in int32.",+          "Corresponds to Haskell's negate :: Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+negateFloat64 :: Packaging.PrimitiveDefinition+negateFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.negateFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Negate a floating-point number."),+        Packaging.entityMetadataComments = [+          "Sign reversal of a float64. Equivalent to IEEE 754 \2677.5.1 negate: flips the sign bit, so negate(\2832) = \2832 (sign flips), negate(\177\8734) = \177\8734 (sign flips), and negate(NaN) is a NaN (sign may flip; payload preserved).",+          "This is a bit-level operation that does not raise any floating-point exception. Corresponds to Haskell's negate :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+odd :: Packaging.PrimitiveDefinition+odd =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.odd"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether an integer is odd."),+        Packaging.entityMetadataComments = [+          "True if the argument is not divisible by 2 (i.e. x mod 2 \8800 0), false otherwise.",+          "Total on all int32 inputs including negative numbers and minBound. Corresponds to Haskell's odd :: Int32 -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.not")),+            Core.applicationArgument = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.math.even")),+              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Test whether an integer is odd, defined as the negation of even.")))]))})))}+pi :: Packaging.PrimitiveDefinition+pi =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.pi"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The mathematical constant pi."),+        Packaging.entityMetadataComments = [+          "The mathematical constant \960 \8776 3.141592653589793, the ratio of a circle's circumference to its diameter, as the nearest representable float64.",+          "Corresponds to Haskell's pi :: Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+pow :: Packaging.PrimitiveDefinition+pow =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.pow"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Raise the first argument to the power of the second."),+        Packaging.entityMetadataComments = [+          "pow(x, y) = x^y.",+          "Follows the IEEE 754 \2681.2 pow operation: pow(\2832, y) for y < 0 is \177\8734 (with division-by-zero exception); pow(\2832, y) for y > 0 is \2832 if y is an odd integer, else +0; pow(1, y) = 1 for any y including NaN; pow(x, \2832) = 1 for any x including NaN; pow(x, y) for negative x and non-integer y is NaN (with invalid-operation exception); pow(\177\8734, y) follows the limits in the usual way. Otherwise the result is x^y rounded to the nearest representable float64.",+          "Corresponds to Haskell's (**) :: Double -> Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+range :: Packaging.PrimitiveDefinition+range =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.range"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Construct the inclusive integer range from the first to the second argument."),+        Packaging.entityMetadataComments = [+          "range(a, b) returns the list [a, a+1, ..., b]. The range is inclusive at both ends; if a > b the result is the empty list (i.e. the range does not count downward). For a = b the result is the singleton [a]. The length of the result is max(0, b - a + 1).",+          "Corresponds to Haskell's enumFromTo :: Int32 -> Int32 -> [Int32], equivalent to the list-comprehension form [a..b]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+round :: Packaging.PrimitiveDefinition+round =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.round"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Round a floating-point number to the nearest integer-valued float."),+        Packaging.entityMetadataComments = [+          "Round to the nearest integer value, returned as a float64, with ties rounded to the nearest even integer (banker's rounding). Equivalent to IEEE 754 \2677.3.1 roundToIntegralTiesToEven: round(\2832) = \2832; round(\177\8734) = \177\8734; round(NaN) is NaN.",+          "Note that the return type is float64, not an integer type, so the result can exceed the integer range.",+          "Corresponds to Haskell's fromIntegral . round :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+roundFloat32 :: Packaging.PrimitiveDefinition+roundFloat32 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.roundFloat32"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Round a float32 to the given number of decimal places."),+        Packaging.entityMetadataComments = [+          "roundFloat32(n, x) rounds the float32 value x to n decimal places using round-half-to-even. The result is the nearest float32 representation of x rounded to that decimal precision; if the exact decimal-rounded value is not representable in float32 (the usual case), the closest float32 is returned.",+          "Special values pass through: roundFloat32(n, \2832) = \2832; roundFloat32(n, \177\8734) = \177\8734; roundFloat32(n, NaN) is NaN.",+          "Negative n is supported in principle (rounding to powers of ten above 1); host implementations may differ on out-of-range n."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+roundFloat64 :: Packaging.PrimitiveDefinition+roundFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.roundFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Round a float64 to the given number of decimal places."),+        Packaging.entityMetadataComments = [+          "roundFloat64(n, x) rounds the float64 value x to n decimal places using round-half-to-even. The result is the nearest float64 representation of x rounded to that decimal precision; if the exact decimal-rounded value is not representable in float64 (the usual case), the closest float64 is returned.",+          "Special values pass through: roundFloat64(n, \2832) = \2832; roundFloat64(n, \177\8734) = \177\8734; roundFloat64(n, NaN) is NaN.",+          "Negative n is supported in principle (rounding to powers of ten above 1); host implementations may differ on out-of-range n."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+signum :: Packaging.PrimitiveDefinition+signum =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.signum"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the sign of an integer as -1, 0, or 1."),+        Packaging.entityMetadataComments = [+          "signum(x) returns -1 if x < 0, 0 if x = 0, and 1 if x > 0.",+          "The function is total and satisfies the identity abs(x) * signum(x) = x for all int32 except minBound (where abs(minBound) * (-1) wraps to minBound rather than equalling -minBound, since +2147483648 is not representable).",+          "Corresponds to Haskell's signum :: Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+sin :: Packaging.PrimitiveDefinition+sin =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.sin"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The sine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Sine of an angle in radians, correctly rounded for finite arguments. The result is in [-1, +1]; sin(\2832) = \2832; sin(\177\8734) is NaN (with invalid-operation exception in IEEE 754); sin(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 sin operation and to Haskell's sin :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+sinh :: Packaging.PrimitiveDefinition+sinh =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.sinh"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The hyperbolic sine of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Hyperbolic sine. sinh(\2832) = \2832; sinh(\177\8734) = \177\8734; sinh(NaN) is NaN. Large-magnitude arguments overflow to \177\8734.",+          "Corresponds to the IEEE 754 \2681.2 sinh operation and to Haskell's sinh :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+sqrt :: Packaging.PrimitiveDefinition+sqrt =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.sqrt"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The non-negative square root of a floating-point number."),+        Packaging.entityMetadataComments = [+          "IEEE 754 binary64 square root. The result is the value of \8730x correctly rounded to the nearest representable float64 under roundTiesToEven.",+          "sqrt(+0) = +0; sqrt(-0) = -0 (sign preserved); sqrt(x) for x < 0 (including -\8734) is NaN (with invalid-operation exception); sqrt(+\8734) = +\8734; sqrt(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2677.4.1 squareRoot operation and to Haskell's sqrt :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+sub :: Packaging.PrimitiveDefinition+sub =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.sub"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Integer subtraction."),+        Packaging.entityMetadataComments = [+          "Two's-complement 32-bit signed integer subtraction. The result is x - y reduced modulo 2^32 and reinterpreted as a signed int32 (i.e. arithmetic wraps silently on overflow, with no exception raised).",+          "The operation is total. Corresponds to Haskell's (-) :: Int32 -> Int32 -> Int32."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+subFloat64 :: Packaging.PrimitiveDefinition+subFloat64 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.subFloat64"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Floating-point subtraction."),+        Packaging.entityMetadataComments = [+          "IEEE 754 binary64 subtraction, defined as x + (-y). The result is correctly rounded to the nearest representable float64 under roundTiesToEven.",+          "Subtracting infinities of the same sign (+\8734 - +\8734 or -\8734 - -\8734) produces a NaN; subtracting any value involving NaN produces a NaN. The difference of two equal finite values is +0 (or -0 under round-toward-negative, which is not the default).",+          "The operation is total: it never raises, but it may produce NaN. Corresponds to the IEEE 754 \2677.4.1 subtraction operation and to Haskell's (-) :: Double -> Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+tan :: Packaging.PrimitiveDefinition+tan =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.tan"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The tangent of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Tangent of an angle in radians, correctly rounded for finite arguments. tan(\2832) = \2832; near odd multiples of \960/2 the result has large magnitude but remains finite (no exception is raised); tan(\177\8734) is NaN (with invalid-operation exception in IEEE 754); tan(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 tan operation and to Haskell's tan :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+tanh :: Packaging.PrimitiveDefinition+tanh =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.tanh"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The hyperbolic tangent of a floating-point number."),+        Packaging.entityMetadataComments = [+          "Hyperbolic tangent. The result is in [-1, +1]; tanh(\2832) = \2832; tanh(\177\8734) = \2833; tanh(NaN) is NaN.",+          "Corresponds to the IEEE 754 \2681.2 tanh operation and to Haskell's tanh :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+truncate :: Packaging.PrimitiveDefinition+truncate =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.truncate"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Truncate a floating-point number toward zero, as a float."),+        Packaging.entityMetadataComments = [+          "Round toward zero (truncate the fractional part), returned as a float64. Equivalent to IEEE 754 \2677.3.1 roundToIntegralTowardZero: truncate(\2832) = \2832; truncate(\177\8734) = \177\8734; truncate(NaN) is NaN; sign of the result matches the sign of the argument (so truncate(-0.7) = -0, truncate(+0.7) = +0).",+          "Note that the return type is float64, not an integer type, so the result can exceed the integer range.",+          "Corresponds to Haskell's fromIntegral . truncate :: Double -> Double."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeFloat Core.FloatTypeFloat64))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Lib/Optionals.hs view
@@ -0,0 +1,664 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.optionals module.++module Hydra.Lib.Optionals where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+apply :: Packaging.PrimitiveDefinition+apply =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.apply"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Applicative apply for optionals: combine an optional function and an optional argument."),+        Packaging.entityMetadataComments = [+          "apply(mf, mx) returns given(f x) when mf is given(f) and mx is given(x), and none if either is none.",+          "The applicative apply for optionals; threads a function-in-context with a value-in-context.",+          "Total. Corresponds to Haskell's (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))}))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "mf"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "mx"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.bind")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "mf"))})),+              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "f"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "x"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "mx"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Applicative apply for optionals, defined in terms of bind and map.")))]))})))}+bind :: Packaging.PrimitiveDefinition+bind =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.bind"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Monadic bind for optionals."),+        Packaging.entityMetadataComments = [+          "bind(m, f) returns f(x) when m is given(x), and none when m is none.",+          "The monadic bind for optionals; used to chain computations that may be absent.",+          "Total. Corresponds to Haskell's (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeOptional (Core.TypeVariable (Core.Name "y")))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "m"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "f"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),+                Core.applicationArgument = (Core.TermOptional Nothing)})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "f"))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Monadic bind for optionals, defined in terms of cases.")))]))})))}+cases :: Packaging.PrimitiveDefinition+cases =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.cases"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Case analysis on an optional, with cases-style argument order."),+        Packaging.entityMetadataComments = [+          "cases(m, def, f) returns f(x) when m is given(x), and def when m is none.",+          "The fundamental eliminator for the optional type; every other primitive in this namespace can be derived from it. The optional value is the first argument, matching the convention for case-statement-like elimination.",+          "Total. Argument order is (m, def, f) rather than Haskell's maybe :: (def, f, m)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "y")),+            Typing.parameterIsLazy = True},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "y"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+cat :: Packaging.PrimitiveDefinition+cat =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.cat"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Concatenate optionals, keeping only the present values."),+        Packaging.entityMetadataComments = [+          "cat(xs) returns the list of contained values from given elements of xs, in original order; none elements are discarded.",+          "Total. Corresponds to Haskell's Data.Maybe.catMaybes :: [Maybe a] -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeOptional (Core.TypeVariable (Core.Name "x")))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "xs"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldr")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "m"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "acc"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "v"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.cons")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))}))})),+              Core.applicationArgument = (Core.TermList [])})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Catenate a list of optionals, keeping only the present values.")))]))})))}+compose :: Packaging.PrimitiveDefinition+compose =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.compose"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Kleisli composition for optionals."),+        Packaging.entityMetadataComments = [+          "compose(f, g, x) returns the Kleisli composition of f and g applied to x: bind(f(x), g).",+          "If either f or the second stage produces none, the result is none.",+          "Total. Corresponds to Haskell's Kleisli composition for Maybe, (>=>) :: (a -> Maybe b) -> (b -> Maybe c) -> a -> Maybe c."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "z"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeOptional (Core.TypeVariable (Core.Name "y")))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "y")),+              Core.functionTypeCodomain = (Core.TypeOptional (Core.TypeVariable (Core.Name "z")))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "z")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "g"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.bind")),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "g"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Kleisli composition for optionals, defined in terms of bind.")))]))})))}+fromOptional :: Packaging.PrimitiveDefinition+fromOptional =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.fromOptional"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the value contained in an optional, falling back to a default if absent."),+        Packaging.entityMetadataComments = [+          "fromOptional(def, m) returns x when m is given(x), and def when m is none.",+          "Total. Corresponds to Haskell's Data.Maybe.fromMaybe :: a -> Maybe a -> a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = True},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "x"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "def"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "m"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (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.TermVariable (Core.Name "m"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "def"))})),+              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Return the contained value or a default, defined in terms of cases.")))]))})))}+isGiven :: Packaging.PrimitiveDefinition+isGiven =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.isGiven"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether an optional is present (given)."),+        Packaging.entityMetadataComments = [+          "isGiven(m) returns true iff m is a given variant.",+          "Total. Corresponds to Haskell's Data.Maybe.isJust :: Maybe a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "m"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (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.TermVariable (Core.Name "m"))})),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})),+            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "_"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean True))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Test for presence, defined in terms of cases.")))]))})))}+isNone :: Packaging.PrimitiveDefinition+isNone =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.isNone"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether an optional is absent (none)."),+        Packaging.entityMetadataComments = [+          "isNone(m) returns true iff m is the none variant.",+          "Total. Corresponds to Haskell's Data.Maybe.isNothing :: Maybe a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "m"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (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.TermVariable (Core.Name "m"))})),+              Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})),+            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "_"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLiteral (Core.LiteralBoolean False))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Test for absence, defined in terms of cases.")))]))})))}+map :: Packaging.PrimitiveDefinition+map =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.map"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function over an optional."),+        Packaging.entityMetadataComments = [+          "map(f, m) returns given(f x) when m is given(x), and none when m is none.",+          "The functor instance for optionals.",+          "Total. Corresponds to Haskell's fmap :: (a -> b) -> Maybe a -> Maybe b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "m"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (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.TermVariable (Core.Name "m"))})),+                Core.applicationArgument = (Core.TermOptional Nothing)})),+              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermOptional (Just (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Map a function over an optional, defined in terms of cases.")))]))})))}+mapOptional :: Packaging.PrimitiveDefinition+mapOptional =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.mapOptional"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a partial function over a list, keeping only the present results."),+        Packaging.entityMetadataComments = [+          "mapOptional(f, xs) applies f to each element of xs and returns the list of contained values from given results in original order; none results are discarded.",+          "Total. Corresponds to Haskell's Data.Maybe.mapMaybe :: (a -> Maybe b) -> [a] -> [b]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeOptional (Core.TypeVariable (Core.Name "y")))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "xs"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cat")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Map a partial function and keep only the present results, defined in terms of lists.map and cat.")))]))})))}+pure :: Packaging.PrimitiveDefinition+pure =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.pure"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Wrap a value in given."),+        Packaging.entityMetadataComments = [+          "pure(x) = given(x). The applicative pure for optionals.",+          "Total. Corresponds to Haskell's pure :: a -> Maybe a / Just."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermOptional (Just (Core.TermVariable (Core.Name "x"))))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Wrap a value in given.")))]))})))}+toList :: Packaging.PrimitiveDefinition+toList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.toList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert an optional to a list: given x maps to [x], none to []."),+        Packaging.entityMetadataComments = [+          "toList(m) returns [x] when m is given(x), and the empty list when m is none.",+          "Total. Corresponds to Haskell's Data.Maybe.maybeToList :: Maybe a -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "m"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (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.TermVariable (Core.Name "m"))})),+              Core.applicationArgument = (Core.TermList [])})),+            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermList [+                Core.TermVariable (Core.Name "x")])}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Convert an optional to a list, defined in terms of cases.")))]))})))}
+ src/main/haskell/Hydra/Lib/Pairs.hs view
@@ -0,0 +1,174 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.pairs module.++module Hydra.Lib.Pairs where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+bimap :: Packaging.PrimitiveDefinition+bimap =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.pairs.bimap"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map over both elements of a pair."),+        Packaging.entityMetadataComments = [+          "bimap(f, g, p) returns a new pair (f(first(p)), g(second(p))). The bifunctor map for pairs.",+          "Total. Corresponds to Haskell's Data.Bifunctor.bimap :: (a -> c) -> (b -> d) -> (a, b) -> (c, d)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "a"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "b"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "c"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "d"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "c"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "b")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "d"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypePair (Core.PairType {+              Core.pairTypeFirst = (Core.TypeVariable (Core.Name "a")),+              Core.pairTypeSecond = (Core.TypeVariable (Core.Name "b"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypePair (Core.PairType {+            Core.pairTypeFirst = (Core.TypeVariable (Core.Name "c")),+            Core.pairTypeSecond = (Core.TypeVariable (Core.Name "d"))}))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "g"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "p"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermPair (+                Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.first")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}),+                (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "g")),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.second")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}))))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Map over both elements of a pair, defined in terms of first and second.")))]))})))}+first :: Packaging.PrimitiveDefinition+first =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.pairs.first"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Get the first element of a pair."),+        Packaging.entityMetadataComments = [+          "first(p) returns the first component of the pair p.",+          "Total. Corresponds to Haskell's fst :: (a, b) -> a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "a"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "b"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypePair (Core.PairType {+              Core.pairTypeFirst = (Core.TypeVariable (Core.Name "a")),+              Core.pairTypeSecond = (Core.TypeVariable (Core.Name "b"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "a"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+second :: Packaging.PrimitiveDefinition+second =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.pairs.second"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Get the second element of a pair."),+        Packaging.entityMetadataComments = [+          "second(p) returns the second component of the pair p.",+          "Total. Corresponds to Haskell's snd :: (a, b) -> b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "a"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "b"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypePair (Core.PairType {+              Core.pairTypeFirst = (Core.TypeVariable (Core.Name "a")),+              Core.pairTypeSecond = (Core.TypeVariable (Core.Name "b"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "b"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Lib/Regex.hs view
@@ -0,0 +1,226 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.regex module.++module Hydra.Lib.Regex where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+find :: Packaging.PrimitiveDefinition+find =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.regex.find"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Find the first regex match within a string, returning the matched substring if any."),+        Packaging.entityMetadataComments = [+          "find(pat, s) returns Just(t) where t is the leftmost substring of s matching pat, or Nothing if pat does not match anywhere in s.",+          "Regex syntax is host-defined; behavior tends to converge on the intersection of ECMA-262 and POSIX-ERE features (literal characters, character classes, alternation, anchors ^ and $, repetition with ?/*/+/{n,m}, grouping with parentheses), but extension features (lookaround, backreferences, Unicode property classes, named groups, engine-specific flags) vary widely. For portable code, restrict patterns to the common subset.",+          "Total in the sense that no error is raised at the kernel level; behavior on an ill-formed pattern is host-defined."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral Core.LiteralTypeString))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+findAll :: Packaging.PrimitiveDefinition+findAll =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.regex.findAll"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Find all non-overlapping regex matches within a string."),+        Packaging.entityMetadataComments = [+          "findAll(pat, s) returns the list of all leftmost, non-overlapping matches of pat in s, in the order they appear. Returns the empty list if pat does not match anywhere.",+          "Regex syntax is host-defined; see find for the common-subset caveat.",+          "Total; ill-formed patterns are host-defined."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+matches :: Packaging.PrimitiveDefinition+matches =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.regex.matches"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether a regex matches anywhere in a string."),+        Packaging.entityMetadataComments = [+          "matches(pat, s) returns true iff pat matches somewhere in s (not anchored to the start or end; for whole-string matching, anchor the pattern explicitly with ^ and $).",+          "Regex syntax is host-defined; see find for the common-subset caveat.",+          "Total; ill-formed patterns are host-defined."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+replace :: Packaging.PrimitiveDefinition+replace =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.regex.replace"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Replace the first regex match in a string with a replacement string."),+        Packaging.entityMetadataComments = [+          "replace(pat, repl, s) returns s with the first leftmost match of pat replaced by repl. If pat does not match, s is returned unchanged.",+          "Replacement-string syntax (capture-group references such as $1 or \\\\1, literal escapes) is host-defined.",+          "Regex syntax is host-defined; see find for the common-subset caveat.",+          "Total; ill-formed patterns and replacement strings are host-defined."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+replaceAll :: Packaging.PrimitiveDefinition+replaceAll =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.regex.replaceAll"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Replace all non-overlapping regex matches in a string with a replacement string."),+        Packaging.entityMetadataComments = [+          "replaceAll(pat, repl, s) returns s with every leftmost, non-overlapping match of pat replaced by repl. If pat does not match anywhere, s is returned unchanged.",+          "Replacement-string syntax is host-defined; see replace and find for the common-subset caveats.",+          "Total; ill-formed patterns and replacement strings are host-defined."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg2"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+split :: Packaging.PrimitiveDefinition+split =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.regex.split"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Split a string by occurrences of a regex pattern."),+        Packaging.entityMetadataComments = [+          "split(pat, s) returns the list of substrings of s obtained by splitting on every leftmost, non-overlapping match of pat.",+          "Trailing empty splits are host-defined (some engines retain them, some discard them; for portable code, do not rely on the trailing-empty behavior).",+          "Regex syntax is host-defined; see find for the common-subset caveat.",+          "Total; ill-formed patterns are host-defined."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Lib/Sets.hs view
@@ -0,0 +1,635 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.sets module.++module Hydra.Lib.Sets where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+delete :: Packaging.PrimitiveDefinition+delete =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.delete"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Remove an element from a set."),+        Packaging.entityMetadataComments = [+          "delete(x, s) returns s with x removed; if x is not in s, s is returned unchanged.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.delete :: Ord a => a -> Set a -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+difference :: Packaging.PrimitiveDefinition+difference =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.difference"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the difference of two sets: elements in the first that are not in the second."),+        Packaging.entityMetadataComments = [+          "difference(s1, s2) returns the set of elements that are in s1 but not in s2.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.difference :: Ord a => Set a -> Set a -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "s1"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "s2"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "acc"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "el"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.member")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "s2"))}))})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})),+                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.insert")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.lib.sets.empty"))})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "s1"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Set difference, defined in terms of member and insert.")))]))})))}+empty :: Packaging.PrimitiveDefinition+empty =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.empty"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The empty set."),+        Packaging.entityMetadataComments = [+          "empty is the set with no elements.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.empty :: Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+fromList :: Packaging.PrimitiveDefinition+fromList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.fromList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Construct a set from a list of elements (duplicates removed)."),+        Packaging.entityMetadataComments = [+          "fromList(xs) returns the set containing exactly the distinct elements of xs; duplicates are discarded.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.fromList :: Ord a => [a] -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+insert :: Packaging.PrimitiveDefinition+insert =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.insert"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Add an element to a set."),+        Packaging.entityMetadataComments = [+          "insert(x, s) returns s with x added; if x is already in s, s is returned unchanged.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.insert :: Ord a => a -> Set a -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+intersection :: Packaging.PrimitiveDefinition+intersection =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.intersection"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the intersection of two sets: elements present in both."),+        Packaging.entityMetadataComments = [+          "intersection(s1, s2) returns the set of elements present in both s1 and s2.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.intersection :: Ord a => Set a -> Set a -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "s1"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "s2"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "acc"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "el"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.member")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "s2"))}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.insert")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.lib.sets.empty"))})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "s1"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Set intersection, defined in terms of member and insert.")))]))})))}+map :: Packaging.PrimitiveDefinition+map =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.map"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Map a function over a set."),+        Packaging.entityMetadataComments = [+          "map(f, s) returns the set of f(x) for each x in s. Elements that f maps to the same image are deduplicated by the result type's ordering.",+          "Requires 'ordering' constraints on both the input and output element types.",+          "Total. Corresponds to Haskell's Data.Set.map :: (Ord a, Ord b) => (a -> b) -> Set a -> Set b."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "y")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "s"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.fromList")),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "f"))})),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Map a function over a set, defined in terms of toList, lists.map and fromList.")))]))})))}+member :: Packaging.PrimitiveDefinition+member =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.member"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether an element is in a set."),+        Packaging.entityMetadataComments = [+          "member(x, s) returns true iff x is an element of s.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.member :: Ord a => a -> Set a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+null :: Packaging.PrimitiveDefinition+null =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.null"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Test whether a set is empty."),+        Packaging.entityMetadataComments = [+          "null(s) returns true iff s has no elements.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.null :: Set a -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+singleton :: Packaging.PrimitiveDefinition+singleton =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.singleton"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Construct a set containing a single element."),+        Packaging.entityMetadataComments = [+          "singleton(x) returns the set containing exactly the element x.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.singleton :: a -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeVariable (Core.Name "x")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+size :: Packaging.PrimitiveDefinition+size =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.size"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the number of elements in a set."),+        Packaging.entityMetadataComments = [+          "size(s) returns the number of elements in s as an int32.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.size :: Set a -> Int (with narrowing to int32)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+toList :: Packaging.PrimitiveDefinition+toList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.toList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a set to a list (in ascending order)."),+        Packaging.entityMetadataComments = [+          "toList(s) returns the elements of s as a list, in ascending order under the element type's ordering.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.toAscList :: Set a -> [a]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+union :: Packaging.PrimitiveDefinition+union =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.union"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the union of two sets: elements in either."),+        Packaging.entityMetadataComments = [+          "union(s1, s2) returns the set of elements that are in s1 or in s2 (or both).",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.union :: Ord a => Set a -> Set a -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeSet (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "s1"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "s2"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")),+                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "acc"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "el"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.insert")),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "el"))})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))}))}))}))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "s2"))})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "s1"))}))}))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Set union, defined in terms of insert and toList.")))]))})))}+unions :: Packaging.PrimitiveDefinition+unions =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.sets.unions"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Compute the union of a list of sets."),+        Packaging.entityMetadataComments = [+          "unions(ss) returns the union of every set in ss. Equivalent to folding union over ss starting from empty.",+          "Requires an 'ordering' constraint on the element type.",+          "Total. Corresponds to Haskell's Data.Set.unions :: Ord a => [Set a] -> Set a."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = [+              Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeSet (Core.TypeVariable (Core.Name "x")))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeSet (Core.TypeVariable (Core.Name "x")))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = (Just (Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "ss"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermApplication (Core.Application {+            Core.applicationFunction = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.foldl")),+                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "acc"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "s"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.union")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))})),+              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.lib.sets.empty"))})),+            Core.applicationArgument = (Core.TermVariable (Core.Name "ss"))}))})),+        Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+          (+            Core.TermVariable (Core.Name "description"),+            (Core.TermLiteral (Core.LiteralString "Union of a list of sets, defined in terms of foldl and union.")))]))})))}
+ src/main/haskell/Hydra/Lib/Strings.hs view
@@ -0,0 +1,381 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Primitives in the hydra.lib.strings module.++module Hydra.Lib.Strings where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+cat :: Packaging.PrimitiveDefinition+cat =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.cat"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Concatenate a list of strings into a single string."),+        Packaging.entityMetadataComments = [+          "cat(xs) returns the string formed by concatenating every string in xs in order.",+          "Total. Corresponds to Haskell's concat :: [String] -> String."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+cat2 :: Packaging.PrimitiveDefinition+cat2 =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.cat2"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Concatenate two strings."),+        Packaging.entityMetadataComments = [+          "cat2(s, t) returns the concatenation of s and t.",+          "Total. Corresponds to Haskell's (++) :: String -> String -> String."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+fromList :: Packaging.PrimitiveDefinition+fromList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.fromList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a list of Unicode code points to a string."),+        Packaging.entityMetadataComments = [+          "fromList(cs) returns the string whose characters are the Unicode code points in cs, in order.",+          "Code points outside the valid Unicode range [0, 0x10FFFF] yield a host-defined result (typically substitution with U+FFFD or truncation of the bits).",+          "Total. The inverse of toList."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+intercalate :: Packaging.PrimitiveDefinition+intercalate =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.intercalate"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Join a list of strings with a separator between each element."),+        Packaging.entityMetadataComments = [+          "intercalate(sep, xs) returns the strings in xs concatenated with sep inserted between each pair of adjacent strings; for the empty list the result is the empty string, and for a singleton list the result is the single string.",+          "Total. Corresponds to Haskell's Data.List.intercalate :: String -> [String] -> String."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+length :: Packaging.PrimitiveDefinition+length =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.length"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Return the length of a string."),+        Packaging.entityMetadataComments = [+          "length(s) returns the number of Unicode code points in s as an int32.",+          "Note: this is the code-point count, not the byte count or the grapheme-cluster count, so a four-byte UTF-8 character counts as one and an emoji built from multiple code points counts as the number of code points it uses.",+          "Total on strings shorter than 2^31-1 code points."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+lines :: Packaging.PrimitiveDefinition+lines =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.lines"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Split a string into lines."),+        Packaging.entityMetadataComments = [+          "lines(s) splits s into a list of lines, splitting on newline characters (U+000A).",+          "The trailing newline is consumed but does not produce an empty trailing element (matching Haskell's lines behavior).",+          "Total. Corresponds to Haskell's lines :: String -> [String]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+maybeCharAt :: Packaging.PrimitiveDefinition+maybeCharAt =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.maybeCharAt"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Get the Unicode code point of the character at a specific index, returning Nothing if out of bounds."),+        Packaging.entityMetadataComments = [+          "maybeCharAt(i, s) returns Just(c) where c is the Unicode code point at position i in s, or Nothing if i is negative or i >= length(s).",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeOptional (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+null :: Packaging.PrimitiveDefinition+null =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.null"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Check whether a string is empty."),+        Packaging.entityMetadataComments = [+          "null(s) returns true iff s is the empty string.",+          "Total. Corresponds to Haskell's null :: String -> Bool."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeBoolean)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+splitOn :: Packaging.PrimitiveDefinition+splitOn =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.splitOn"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Split a string on a delimiter string."),+        Packaging.entityMetadataComments = [+          "splitOn(sep, s) returns the list of substrings of s obtained by splitting on every occurrence of the non-empty delimiter sep. Adjacent or boundary delimiters produce empty-string elements in the result.",+          "Behavior when sep is empty is host-defined and should not be relied upon.",+          "Total. Corresponds to Haskell's Data.List.Split.splitOn :: String -> String -> [String]."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg1"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+toList :: Packaging.PrimitiveDefinition+toList =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.toList"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a string to a list of Unicode code points."),+        Packaging.entityMetadataComments = [+          "toList(s) returns the list of Unicode code points making up s, in order. Each code point is represented as an int32.",+          "Total. The inverse of fromList."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeList (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+toLower :: Packaging.PrimitiveDefinition+toLower =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.toLower"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a string to lowercase."),+        Packaging.entityMetadataComments = [+          "toLower(s) returns s with each character replaced by its Unicode simple (one-to-one) lowercase mapping, or itself if it has no lowercase mapping.",+          "This is a code-point-by-code-point operation, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not lowercase to \"ss\"; it returns itself).",+          "For text intended for human-readable display in locales with non-trivial case mappings, prefer a host-specific full case-folding API.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+toUpper :: Packaging.PrimitiveDefinition+toUpper =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.toUpper"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Convert a string to uppercase."),+        Packaging.entityMetadataComments = [+          "toUpper(s) returns s with each character replaced by its Unicode simple (one-to-one) uppercase mapping, or itself if it has no uppercase mapping.",+          "This is a code-point-by-code-point operation, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not uppercase to \"SS\"; it returns itself).",+          "For text intended for human-readable display in locales with non-trivial case mappings, prefer a host-specific full case-folding API.",+          "Total."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+unlines :: Packaging.PrimitiveDefinition+unlines =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.unlines"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Join a list of strings with newlines, appending a trailing newline."),+        Packaging.entityMetadataComments = [+          "unlines(xs) returns the concatenation of every string in xs with a newline character (U+000A) appended after each, including the last. The inverse of lines for normalized input.",+          "Total. Corresponds to Haskell's unlines :: [String] -> String."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "arg0"),+            Typing.parameterDescription = Nothing,+            Typing.parameterType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString)),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}
+ src/main/haskell/Hydra/Literals.hs view
@@ -0,0 +1,55 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Conversion functions for literal values.++module Hydra.Literals where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Literals as Literals+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Convert a bigint to an integer value of a given type (note: lossy)+bigintToIntegerValue :: Core.IntegerType -> Integer -> Core.IntegerValue+bigintToIntegerValue it bi =+    case it of+      Core.IntegerTypeBigint -> Core.IntegerValueBigint bi+      Core.IntegerTypeInt8 -> Core.IntegerValueInt8 (Literals.bigintToInt8 bi)+      Core.IntegerTypeInt16 -> Core.IntegerValueInt16 (Literals.bigintToInt16 bi)+      Core.IntegerTypeInt32 -> Core.IntegerValueInt32 (Literals.bigintToInt32 bi)+      Core.IntegerTypeInt64 -> Core.IntegerValueInt64 (Literals.bigintToInt64 bi)+      Core.IntegerTypeUint8 -> Core.IntegerValueUint8 (Literals.bigintToUint8 bi)+      Core.IntegerTypeUint16 -> Core.IntegerValueUint16 (Literals.bigintToUint16 bi)+      Core.IntegerTypeUint32 -> Core.IntegerValueUint32 (Literals.bigintToUint32 bi)+      Core.IntegerTypeUint64 -> Core.IntegerValueUint64 (Literals.bigintToUint64 bi)+-- | Convert an integer value of any precision to a bigint+integerValueToBigint :: Core.IntegerValue -> Integer+integerValueToBigint x =+    case x of+      Core.IntegerValueBigint v0 -> v0+      Core.IntegerValueInt8 v0 -> Literals.int8ToBigint v0+      Core.IntegerValueInt16 v0 -> Literals.int16ToBigint v0+      Core.IntegerValueInt32 v0 -> Literals.int32ToBigint v0+      Core.IntegerValueInt64 v0 -> Literals.int64ToBigint v0+      Core.IntegerValueUint8 v0 -> Literals.uint8ToBigint v0+      Core.IntegerValueUint16 v0 -> Literals.uint16ToBigint v0+      Core.IntegerValueUint32 v0 -> Literals.uint32ToBigint v0+      Core.IntegerValueUint64 v0 -> Literals.uint64ToBigint v0
+ src/main/haskell/Hydra/Names.hs view
@@ -0,0 +1,150 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Functions for working with qualified names.++module Hydra.Names where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Given a mapping of namespaces to prefixes, convert a name to a compact string representation+compactName :: M.Map Packaging.ModuleName String -> Core.Name -> String+compactName namespaces name =++      let qualName = qualifyName name+          mns = Util.qualifiedNameModuleName qualName+          local = Util.qualifiedNameLocal qualName+      in (Optionals.cases mns (Core.unName name) (\ns -> Optionals.cases (Maps.lookup ns namespaces) local (\pre -> Strings.cat [+        pre,+        ":",+        local])))+-- | Generate a fresh type variable name, threading InferenceContext+freshName :: Typing.InferenceContext -> (Core.Name, Typing.InferenceContext)+freshName cx =++      let count = Typing.inferenceContextFreshTypeVariableCount cx+      in (+        normalTypeVariable count,+        Typing.InferenceContext {+          Typing.inferenceContextFreshTypeVariableCount = (Math.add count 1),+          Typing.inferenceContextTrace = (Typing.inferenceContextTrace cx)})+-- | Generate multiple fresh type variable names, threading InferenceContext+freshNames :: Int -> Typing.InferenceContext -> ([Core.Name], Typing.InferenceContext)+freshNames n cx =++      let go =+              \acc -> \_ ->+                let names = Pairs.first acc+                    cx0 = Pairs.second acc+                    result = freshName cx0+                    name = Pairs.first result+                    cx1 = Pairs.second result+                in (Lists.concat2 names (Lists.pure name), cx1)+      in (Lists.foldl go ([], cx) (Lists.replicate n ()))+-- | Extract the local part of a name+localNameOf :: Core.Name -> String+localNameOf arg_ = Util.qualifiedNameLocal (qualifyName arg_)+-- | Extract the module name of a name, if any+moduleNameOf :: Core.Name -> Maybe Packaging.ModuleName+moduleNameOf arg_ = Util.qualifiedNameModuleName (qualifyName arg_)+-- | Convert a module name to a file path with the given case convention and file extension+moduleNameToFilePath :: Util.CaseConvention -> Util.FileExtension -> Packaging.ModuleName -> String+moduleNameToFilePath caseConv ext ns =++      let parts = Lists.map (Formatting.convertCase Util.CaseConventionCamel caseConv) (Strings.splitOn "." (Packaging.unModuleName ns))+      in (Strings.cat2 (Strings.cat2 (Strings.intercalate "/" parts) ".") (Util.unFileExtension ext))+-- | Convert a name to file path, given case conventions for namespaces and local names, and assuming '/' as the file path separator+nameToFilePath :: Util.CaseConvention -> Util.CaseConvention -> Util.FileExtension -> Core.Name -> String+nameToFilePath nsConv localConv ext name =++      let qualName = qualifyName name+          ns = Util.qualifiedNameModuleName qualName+          local = Util.qualifiedNameLocal qualName+          nsToFilePath =+                  \nsArg -> Strings.intercalate "/" (Lists.map (\part -> Formatting.convertCase Util.CaseConventionCamel nsConv part) (Strings.splitOn "." (Packaging.unModuleName nsArg)))+          prefix = Optionals.cases ns "" (\n -> Strings.cat2 (nsToFilePath n) "/")+          suffix = Formatting.convertCase Util.CaseConventionPascal localConv local+      in (Strings.cat [+        prefix,+        suffix,+        ".",+        (Util.unFileExtension ext)])+-- | Type variable naming convention follows Haskell: t0, t1, etc.+normalTypeVariable :: Int -> Core.Name+normalTypeVariable i = Core.Name (Strings.cat2 "t" (Literals.showInt32 i))+-- | Prepend a SubtermStep to the InferenceContext's trace. The trace is accumulated backwards as inference descends through subterms; at error-emission time the list is reversed and wrapped into a SubtermPath stamped onto the error.+pushSubtermStep :: Paths.SubtermStep -> Typing.InferenceContext -> Typing.InferenceContext+pushSubtermStep step cx =+    Typing.InferenceContext {+      Typing.inferenceContextFreshTypeVariableCount = (Typing.inferenceContextFreshTypeVariableCount cx),+      Typing.inferenceContextTrace = (Lists.cons step (Typing.inferenceContextTrace cx))}+-- | Construct a qualified (dot-separated) name+qname :: Packaging.ModuleName -> String -> Core.Name+qname ns name =+    Core.Name (Strings.cat [+      Packaging.unModuleName ns,+      ".",+      name])+-- | Split a dot-separated name into a namespace and local name+qualifyName :: Core.Name -> Util.QualifiedName+qualifyName name =++      let parts = Lists.reverse (Strings.splitOn "." (Core.unName name))+      in (Optionals.cases (Lists.uncons parts) (Util.QualifiedName {+        Util.qualifiedNameModuleName = Nothing,+        Util.qualifiedNameLocal = (Core.unName name)}) (\uc ->+        let localName = Pairs.first uc+            restReversed = Pairs.second uc+        in (Logic.ifElse (Lists.null restReversed) (Util.QualifiedName {+          Util.qualifiedNameModuleName = Nothing,+          Util.qualifiedNameLocal = (Core.unName name)}) (Util.QualifiedName {+          Util.qualifiedNameModuleName = (Just (Packaging.ModuleName (Strings.intercalate "." (Lists.reverse restReversed)))),+          Util.qualifiedNameLocal = localName}))))+-- | Restore the original trace from baseCx, while keeping the freshTypeVariableCount from newCx. Used between sibling sub-inferences (e.g. application LHS vs RHS) so that an error in the second sibling doesn't include the first sibling's trace path. Returns a new InferenceContext.+restoreTrace :: Typing.InferenceContext -> Typing.InferenceContext -> Typing.InferenceContext+restoreTrace baseCx newCx =+    Typing.InferenceContext {+      Typing.inferenceContextFreshTypeVariableCount = (Typing.inferenceContextFreshTypeVariableCount newCx),+      Typing.inferenceContextTrace = (Typing.inferenceContextTrace baseCx)}+-- | Generate a unique label by appending a suffix if the label is already in use+uniqueLabel :: S.Set String -> String -> String+uniqueLabel visited l = Logic.ifElse (Sets.member l visited) (uniqueLabel visited (Strings.cat2 l "'")) l+-- | Convert a qualified name to a dot-separated name+unqualifyName :: Util.QualifiedName -> Core.Name+unqualifyName qname =++      let prefix = Optionals.cases (Util.qualifiedNameModuleName qname) "" (\n -> Strings.cat2 (Packaging.unModuleName n) ".")+      in (Core.Name (Strings.cat2 prefix (Util.qualifiedNameLocal qname)))
+ src/main/haskell/Hydra/Packaging.hs view
@@ -0,0 +1,210 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A model for Hydra module names, modules, and packages++module Hydra.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | A definition, which may be either a term, type, or primitive definition+data Definition =+  -- | A term definition+  DefinitionTerm TermDefinition |+  -- | A type definition+  DefinitionType TypeDefinition |+  -- | A primitive definition+  DefinitionPrimitive PrimitiveDefinition+  deriving (Eq, Ord, Read, Show)+_Definition = Core.Name "hydra.packaging.Definition"+_Definition_term = Core.Name "term"+_Definition_type = Core.Name "type"+_Definition_primitive = Core.Name "primitive"+-- | A typed reference to a definition: a type, a term, or a primitive, identified by name+data DefinitionReference =+  -- | A reference to a type definition, by name+  DefinitionReferenceType Core.Name |+  -- | A reference to a term definition, by name+  DefinitionReferenceTerm Core.Name |+  -- | A reference to a primitive definition, by name+  DefinitionReferencePrimitive Core.Name+  deriving (Eq, Ord, Read, Show)+_DefinitionReference = Core.Name "hydra.packaging.DefinitionReference"+_DefinitionReference_type = Core.Name "type"+_DefinitionReference_term = Core.Name "term"+_DefinitionReference_primitive = Core.Name "primitive"+-- | Documentation and lifecycle metadata attachable to a packaging entity (package, module, or definition). Bundling these fields in one type lets future metadata be added without changing the field shape of the entities that carry it.+data EntityMetadata =+  EntityMetadata {+    -- | An optional, concise one-line human-readable summary of the entity.+    entityMetadataDescription :: (Maybe String),+    -- | Zero or more long-form prose paragraphs: cross-cutting semantic conventions, caveats, and references that would otherwise be repeated across the entity's constituents.+    entityMetadataComments :: [String],+    -- | Typed cross-references to related entities, for navigation and documentation.+    entityMetadataSeeAlso :: [EntityReference],+    -- | Optional version-lifecycle milestones for the entity.+    entityMetadataLifecycle :: (Maybe LifecycleInfo)}+  deriving (Eq, Ord, Read, Show)+_EntityMetadata = Core.Name "hydra.packaging.EntityMetadata"+_EntityMetadata_description = Core.Name "description"+_EntityMetadata_comments = Core.Name "comments"+_EntityMetadata_seeAlso = Core.Name "seeAlso"+_EntityMetadata_lifecycle = Core.Name "lifecycle"+-- | A typed reference to a packaging entity: a package, a module, or a definition+data EntityReference =+  -- | A reference to a package, by name+  EntityReferencePackage PackageName |+  -- | A reference to a module, by name+  EntityReferenceModule ModuleName |+  -- | A reference to a definition (type, term, or primitive)+  EntityReferenceDefinition DefinitionReference+  deriving (Eq, Ord, Read, Show)+_EntityReference = Core.Name "hydra.packaging.EntityReference"+_EntityReference_package = Core.Name "package"+_EntityReference_module = Core.Name "module"+_EntityReference_definition = Core.Name "definition"+-- | Version-lifecycle milestones for a packaging entity. Each milestone is independently optional; further milestones (e.g. stableSince, removedSince) may be added without changing dependent types.+data LifecycleInfo =+  LifecycleInfo {+    -- | The version in which the entity was introduced, if known.+    lifecycleInfoAvailableSince :: (Maybe Version),+    -- | The version in which the entity was deprecated, if applicable.+    lifecycleInfoDeprecatedSince :: (Maybe Version)}+  deriving (Eq, Ord, Read, Show)+_LifecycleInfo = Core.Name "hydra.packaging.LifecycleInfo"+_LifecycleInfo_availableSince = Core.Name "availableSince"+_LifecycleInfo_deprecatedSince = Core.Name "deprecatedSince"+-- | A logical collection of elements sharing a common module name, having dependencies on zero or more other modules+data Module =+  Module {+    -- | The name of the module, which is also the common prefix for all element names in the module+    moduleName :: ModuleName,+    -- | Optional documentation and lifecycle metadata for the module+    moduleMetadata :: (Maybe EntityMetadata),+    -- | Any modules which this module directly depends on+    moduleDependencies :: [ModuleDependency],+    -- | The definitions in this module+    moduleDefinitions :: [Definition]}+  deriving (Eq, Ord, Read, Show)+_Module = Core.Name "hydra.packaging.Module"+_Module_name = Core.Name "name"+_Module_metadata = Core.Name "metadata"+_Module_dependencies = Core.Name "dependencies"+_Module_definitions = Core.Name "definitions"+-- | A dependency on another module, identified by its name and (optionally) the package which provides it. When the package is omitted, the resolver searches all packages in scope; a duplicate module name across packages is a resolution error which can be disambiguated by naming the intended package explicitly.+data ModuleDependency =+  ModuleDependency {+    -- | The name of the depended-on module+    moduleDependencyModule :: ModuleName,+    -- | The package providing the depended-on module, if disambiguation is required+    moduleDependencyPackage :: (Maybe PackageName)}+  deriving (Eq, Ord, Read, Show)+_ModuleDependency = Core.Name "hydra.packaging.ModuleDependency"+_ModuleDependency_module = Core.Name "module"+_ModuleDependency_package = Core.Name "package"+-- | The unique name of a module; a prefix for the names of elements defined in the module.+newtype ModuleName =+  ModuleName {+    unModuleName :: String}+  deriving (Eq, Ord, Read, Show)+_ModuleName = Core.Name "hydra.packaging.ModuleName"+-- | A package, which is a named collection of modules with metadata and dependencies+data Package =+  Package {+    -- | The name of the package+    packageName :: PackageName,+    -- | Optional documentation and lifecycle metadata for the package+    packageMetadata :: (Maybe EntityMetadata),+    -- | The packages which this package depends on+    packageDependencies :: [PackageDependency],+    -- | The modules in this package+    packageModules :: [Module]}+  deriving (Eq, Ord, Read, Show)+_Package = Core.Name "hydra.packaging.Package"+_Package_name = Core.Name "name"+_Package_metadata = Core.Name "metadata"+_Package_dependencies = Core.Name "dependencies"+_Package_modules = Core.Name "modules"+-- | A dependency on another package, identified by name and constrained by an optional version specifier+data PackageDependency =+  PackageDependency {+    -- | The name of the depended-on package+    packageDependencyName :: PackageName,+    -- | The version-range constraint on the depended-on package+    packageDependencyVersion :: VersionSpecifier}+  deriving (Eq, Ord, Read, Show)+_PackageDependency = Core.Name "hydra.packaging.PackageDependency"+_PackageDependency_name = Core.Name "name"+_PackageDependency_version = Core.Name "version"+-- | The unique name of a package, e.g. "hydra-kernel" or "hydra-python"+newtype PackageName =+  PackageName {+    unPackageName :: String}+  deriving (Eq, Ord, Read, Show)+_PackageName = Core.Name "hydra.packaging.PackageName"+-- | A primitive definition: the universal, host-independent declarative metadata for a primitive, including name, signature, documentation and lifecycle metadata, totality and purity flags, and an optional default implementation expressed as a Hydra term.+data PrimitiveDefinition =+  PrimitiveDefinition {+    -- | The name of the primitive+    primitiveDefinitionName :: Core.Name,+    -- | Optional documentation and lifecycle metadata for the primitive.+    primitiveDefinitionMetadata :: (Maybe EntityMetadata),+    -- | The signature of the primitive. Always explicit, never inferred.+    primitiveDefinitionSignature :: Typing.TermSignature,+    -- | Whether the primitive is pure (referentially transparent, no observable side effects). Normally true.+    primitiveDefinitionIsPure :: Bool,+    -- | Whether the primitive is total (terminates on every input of its declared type). Normally true.+    primitiveDefinitionIsTotal :: Bool,+    -- | An optional cross-compilable reference implementation of the primitive, expressed as a Hydra term. Used by interpreters lacking a native implementation and as a proof-friendly reference. Distinct from the per-host Primitive.implementation.+    primitiveDefinitionDefaultImplementation :: (Maybe Core.Term)}+  deriving (Eq, Ord, Read, Show)+_PrimitiveDefinition = Core.Name "hydra.packaging.PrimitiveDefinition"+_PrimitiveDefinition_name = Core.Name "name"+_PrimitiveDefinition_metadata = Core.Name "metadata"+_PrimitiveDefinition_signature = Core.Name "signature"+_PrimitiveDefinition_isPure = Core.Name "isPure"+_PrimitiveDefinition_isTotal = Core.Name "isTotal"+_PrimitiveDefinition_defaultImplementation = Core.Name "defaultImplementation"+-- | A term-level definition, including a name, an optional signature, and a term+data TermDefinition =+  TermDefinition {+    -- | The name of the term+    termDefinitionName :: Core.Name,+    -- | Optional documentation and lifecycle metadata for the term definition+    termDefinitionMetadata :: (Maybe EntityMetadata),+    -- | The optional signature of the term. When absent, the signature has yet to be inferred.+    termDefinitionSignature :: (Maybe Typing.TermSignature),+    -- | The term being defined+    termDefinitionBody :: Core.Term}+  deriving (Eq, Ord, Read, Show)+_TermDefinition = Core.Name "hydra.packaging.TermDefinition"+_TermDefinition_name = Core.Name "name"+_TermDefinition_metadata = Core.Name "metadata"+_TermDefinition_signature = Core.Name "signature"+_TermDefinition_body = Core.Name "body"+-- | A type-level definition, including a name and the type scheme+data TypeDefinition =+  TypeDefinition {+    -- | The name of the type+    typeDefinitionName :: Core.Name,+    -- | Optional documentation and lifecycle metadata for the type definition+    typeDefinitionMetadata :: (Maybe EntityMetadata),+    -- | The type scheme being defined+    typeDefinitionBody :: Core.TypeScheme}+  deriving (Eq, Ord, Read, Show)+_TypeDefinition = Core.Name "hydra.packaging.TypeDefinition"+_TypeDefinition_name = Core.Name "name"+_TypeDefinition_metadata = Core.Name "metadata"+_TypeDefinition_body = Core.Name "body"+-- | A version string, e.g. "0.15" or "1.0.0".+newtype Version =+  Version {+    unVersion :: String}+  deriving (Eq, Ord, Read, Show)+_Version = Core.Name "hydra.packaging.Version"+-- | A specifier constraining acceptable versions of a dependency. Currently only the `any` (unit) specifier is defined; future variants such as `exact`, `caret`, and `range` may be added without breaking consumers of the `any` form.+data VersionSpecifier =+  -- | Any version satisfies the dependency+  VersionSpecifierAny+  deriving (Eq, Ord, Read, Show)+_VersionSpecifier = Core.Name "hydra.packaging.VersionSpecifier"+_VersionSpecifier_any = Core.Name "any"
+ src/main/haskell/Hydra/Parsers.hs view
@@ -0,0 +1,158 @@+-- Note: this is an automatically generated file. Do not edit.+-- | General-purpose parser combinators++module Hydra.Parsers where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Equality as Equality+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Try the first parser; if it fails without consuming input, try the second+alt :: Parsing.Parser t0 -> Parsing.Parser t0 -> Parsing.Parser t0+alt p1 p2 =++      let parse =+              \input -> (\x -> case x of+                Parsing.ParseResultSuccess v0 -> Parsing.ParseResultSuccess v0+                Parsing.ParseResultFailure v0 -> Logic.ifElse (Equality.equal (Parsing.parseErrorRemainder v0) input) (Parsing.unParser p2 input) (Parsing.ParseResultFailure v0)) (Parsing.unParser p1 input)+      in (Parsing.Parser parse)+-- | Parse any single character (codepoint)+anyChar :: Parsing.Parser Int+anyChar = satisfy (\_ -> True)+-- | Apply a parser containing a function to a parser containing a value+apply :: Parsing.Parser (t0 -> t1) -> Parsing.Parser t0 -> Parsing.Parser t1+apply pf pa =++      let parse =+              \input -> (\x -> case x of+                Parsing.ParseResultSuccess v0 -> (\x -> case x of+                  Parsing.ParseResultSuccess v1 -> Parsing.ParseResultSuccess (Parsing.ParseSuccess {+                    Parsing.parseSuccessValue = (Parsing.parseSuccessValue v0 (Parsing.parseSuccessValue v1)),+                    Parsing.parseSuccessRemainder = (Parsing.parseSuccessRemainder v1)})+                  Parsing.ParseResultFailure v1 -> Parsing.ParseResultFailure v1) (Parsing.unParser pa (Parsing.parseSuccessRemainder v0))+                Parsing.ParseResultFailure v0 -> Parsing.ParseResultFailure v0) (Parsing.unParser pf input)+      in (Parsing.Parser parse)+-- | Parse something between an opening and closing parser+between :: Parsing.Parser t0 -> Parsing.Parser t1 -> Parsing.Parser t2 -> Parsing.Parser t2+between open close p = bind open (\_ -> bind p (\x -> bind close (\_2 -> pure x)))+-- | Sequence two parsers, passing the result of the first to a function that produces the second+bind :: Parsing.Parser t0 -> (t0 -> Parsing.Parser t1) -> Parsing.Parser t1+bind pa f =++      let parse =+              \input -> (\x -> case x of+                Parsing.ParseResultSuccess v0 -> Parsing.unParser (f (Parsing.parseSuccessValue v0)) (Parsing.parseSuccessRemainder v0)+                Parsing.ParseResultFailure v0 -> Parsing.ParseResultFailure v0) (Parsing.unParser pa input)+      in (Parsing.Parser parse)+-- | Parse a specific character (codepoint)+char :: Int -> Parsing.Parser Int+char c = satisfy (\x -> Equality.equal x c)+-- | Try each parser in the list until one succeeds+choice :: [Parsing.Parser t0] -> Parsing.Parser t0+choice ps = Lists.foldl alt (fail "no choice matched") ps+-- | A parser that succeeds only at the end of input+eof :: Parsing.Parser ()+eof =+    Parsing.Parser (\input -> Logic.ifElse (Equality.equal input "") (Parsing.ParseResultSuccess (Parsing.ParseSuccess {+      Parsing.parseSuccessValue = (),+      Parsing.parseSuccessRemainder = ""})) (Parsing.ParseResultFailure (Parsing.ParseError {+      Parsing.parseErrorMessage = "expected end of input",+      Parsing.parseErrorRemainder = input})))+-- | A parser that always fails with the given error message+fail :: String -> Parsing.Parser t0+fail msg =+    Parsing.Parser (\input -> Parsing.ParseResultFailure (Parsing.ParseError {+      Parsing.parseErrorMessage = msg,+      Parsing.parseErrorRemainder = input}))+-- | Create a parser that defers construction of another parser until parsing time. This is essential for breaking recursive parser definitions.+lazy :: (() -> Parsing.Parser t0) -> Parsing.Parser t0+lazy f = Parsing.Parser (\input -> Parsing.unParser (f ()) input)+-- | Parse zero or more occurrences of the given parser+many :: Parsing.Parser t0 -> Parsing.Parser [t0]+many p = alt (some p) (pure [])+-- | Apply a function to the result of a parser+map :: (t0 -> t1) -> Parsing.Parser t0 -> Parsing.Parser t1+map f pa =++      let parse =+              \input -> (\x -> case x of+                Parsing.ParseResultSuccess v0 -> Parsing.ParseResultSuccess (Parsing.ParseSuccess {+                  Parsing.parseSuccessValue = (f (Parsing.parseSuccessValue v0)),+                  Parsing.parseSuccessRemainder = (Parsing.parseSuccessRemainder v0)})+                Parsing.ParseResultFailure v0 -> Parsing.ParseResultFailure v0) (Parsing.unParser pa input)+      in (Parsing.Parser parse)+-- | Optionally parse something, returning Nothing if it fails+optional :: Parsing.Parser t0 -> Parsing.Parser (Maybe t0)+optional p = alt (map Optionals.pure p) (pure Nothing)+-- | A parser that always succeeds with the given value without consuming input+pure :: t0 -> Parsing.Parser t0+pure a =+    Parsing.Parser (\input -> Parsing.ParseResultSuccess (Parsing.ParseSuccess {+      Parsing.parseSuccessValue = a,+      Parsing.parseSuccessRemainder = input}))+-- | Run a parser on the given input string+runParser :: Parsing.Parser t0 -> String -> Parsing.ParseResult t0+runParser p input = Parsing.unParser p input+-- | Parse a character (codepoint) that satisfies the given predicate+satisfy :: (Int -> Bool) -> Parsing.Parser Int+satisfy pred =++      let parse =+              \input ->+                let codes = Strings.toList input+                in (Optionals.cases (Lists.maybeHead codes) (Parsing.ParseResultFailure (Parsing.ParseError {+                  Parsing.parseErrorMessage = "unexpected end of input",+                  Parsing.parseErrorRemainder = input})) (\c ->+                  let rest = Strings.fromList (Lists.drop 1 codes)+                  in (Logic.ifElse (pred c) (Parsing.ParseResultSuccess (Parsing.ParseSuccess {+                    Parsing.parseSuccessValue = c,+                    Parsing.parseSuccessRemainder = rest})) (Parsing.ParseResultFailure (Parsing.ParseError {+                    Parsing.parseErrorMessage = "character did not satisfy predicate",+                    Parsing.parseErrorRemainder = input})))))+      in (Parsing.Parser parse)+-- | Parse zero or more occurrences separated by a separator+sepBy :: Parsing.Parser t0 -> Parsing.Parser t1 -> Parsing.Parser [t0]+sepBy p sep = alt (sepBy1 p sep) (pure [])+-- | Parse one or more occurrences separated by a separator+sepBy1 :: Parsing.Parser t0 -> Parsing.Parser t1 -> Parsing.Parser [t0]+sepBy1 p sep = bind p (\x -> bind (many (bind sep (\_ -> p))) (\xs -> pure (Lists.cons x xs)))+-- | Parse one or more occurrences of the given parser+some :: Parsing.Parser t0 -> Parsing.Parser [t0]+some p = bind p (\x -> bind (many p) (\xs -> pure (Lists.cons x xs)))+-- | Parse a specific string+string :: String -> Parsing.Parser String+string str =+    Parsing.Parser (\input ->+      let strCodes = Strings.toList str+          inputCodes = Strings.toList input+          strLen = Lists.length strCodes+          inputPrefix = Lists.take strLen inputCodes+      in (Logic.ifElse (Equality.equal strCodes inputPrefix) (Parsing.ParseResultSuccess (Parsing.ParseSuccess {+        Parsing.parseSuccessValue = str,+        Parsing.parseSuccessRemainder = (Strings.fromList (Lists.drop strLen inputCodes))})) (Parsing.ParseResultFailure (Parsing.ParseError {+        Parsing.parseErrorMessage = (Strings.cat2 "expected: " str),+        Parsing.parseErrorRemainder = input}))))
+ src/main/haskell/Hydra/Parsing.hs view
@@ -0,0 +1,44 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Parser combinator types for text parsing++module Hydra.Parsing where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | An error which occurred while parsing+data ParseError =+  ParseError {+    -- | An error message+    parseErrorMessage :: String,+    -- | The remaining input at the point of failure+    parseErrorRemainder :: String}+  deriving (Eq, Ord, Read, Show)+_ParseError = Core.Name "hydra.parsing.ParseError"+_ParseError_message = Core.Name "message"+_ParseError_remainder = Core.Name "remainder"+-- | The result of a parse operation+data ParseResult a =+  -- | A successful parse, with a value and the remaining unparsed input+  ParseResultSuccess (ParseSuccess a) |+  -- | A failed parse, with an error message and the remaining input+  ParseResultFailure ParseError+  deriving (Eq, Ord, Read, Show)+_ParseResult = Core.Name "hydra.parsing.ParseResult"+_ParseResult_success = Core.Name "success"+_ParseResult_failure = Core.Name "failure"+-- | A successful parse result+data ParseSuccess a =+  ParseSuccess {+    -- | The parsed value+    parseSuccessValue :: a,+    -- | The remaining unparsed input+    parseSuccessRemainder :: String}+  deriving (Eq, Ord, Read, Show)+_ParseSuccess = Core.Name "hydra.parsing.ParseSuccess"+_ParseSuccess_value = Core.Name "value"+_ParseSuccess_remainder = Core.Name "remainder"+-- | A parser which consumes characters from a string and produces a value+newtype Parser a =+  Parser {+    unParser :: (String -> ParseResult a)}+_Parser = Core.Name "hydra.parsing.Parser"
+ src/main/haskell/Hydra/Paths.hs view
@@ -0,0 +1,219 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A model for subterm and subtype access patterns++module Hydra.Paths where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | An edge in a subterm graph, connecting two nodes via a path+data SubtermEdge =+  SubtermEdge {+    -- | The source node of the edge+    subtermEdgeSource :: SubtermNode,+    -- | The subterm path connecting source to target+    subtermEdgePath :: SubtermPath,+    -- | The target node of the edge+    subtermEdgeTarget :: SubtermNode}+  deriving (Eq, Ord, Read, Show)+_SubtermEdge = Core.Name "hydra.paths.SubtermEdge"+_SubtermEdge_source = Core.Name "source"+_SubtermEdge_path = Core.Name "path"+_SubtermEdge_target = Core.Name "target"+-- | A graph of subterm nodes and edges, representing term access patterns+data SubtermGraph =+  SubtermGraph {+    -- | All nodes in the graph+    subtermGraphNodes :: [SubtermNode],+    -- | All edges in the graph+    subtermGraphEdges :: [SubtermEdge]}+  deriving (Eq, Ord, Read, Show)+_SubtermGraph = Core.Name "hydra.paths.SubtermGraph"+_SubtermGraph_nodes = Core.Name "nodes"+_SubtermGraph_edges = Core.Name "edges"+-- | A node in a subterm graph, representing a term or subterm+data SubtermNode =+  SubtermNode {+    -- | The qualified name of the term+    subtermNodeName :: Core.Name,+    -- | A human-readable label for the node+    subtermNodeLabel :: String,+    -- | A unique identifier for the node+    subtermNodeId :: String}+  deriving (Eq, Ord, Read, Show)+_SubtermNode = Core.Name "hydra.paths.SubtermNode"+_SubtermNode_name = Core.Name "name"+_SubtermNode_label = Core.Name "label"+_SubtermNode_id = Core.Name "id"+-- | A sequence of subterm steps forming a path through a term+newtype SubtermPath =+  SubtermPath {+    unSubtermPath :: [SubtermStep]}+  deriving (Eq, Ord, Read, Show)+_SubtermPath = Core.Name "hydra.paths.SubtermPath"+-- | A function which maps from a term to a particular immediate subterm+data SubtermStep =+  -- | Access the body of an annotated term+  SubtermStepAnnotatedBody |+  -- | Access the function of an application term+  SubtermStepApplicationFunction |+  -- | Access the argument of an application term+  SubtermStepApplicationArgument |+  -- | Access the body of a lambda term+  SubtermStepLambdaBody |+  -- | Access the default case of a union elimination+  SubtermStepUnionCasesDefault |+  -- | Access a specific branch of a union elimination by field name+  SubtermStepUnionCasesBranch Core.Name |+  -- | Access the body of a let term+  SubtermStepLetBody |+  -- | Access a specific binding in a let term by variable name+  SubtermStepLetBinding Core.Name |+  -- | Access an element of a list by index+  SubtermStepListElement Int |+  -- | Access a key in a map by index+  SubtermStepMapKey Int |+  -- | Access a value in a map by index+  SubtermStepMapValue Int |+  -- | Access the term inside a given (present) optional value+  SubtermStepOptionalTerm |+  -- | Access an element of a product (tuple) by index+  SubtermStepProductTerm Int |+  -- | Access a field of a record by field name+  SubtermStepRecordField Core.Name |+  -- | Access an element of a set by index+  SubtermStepSetElement Int |+  -- | Access the term inside a sum variant+  SubtermStepSumTerm |+  -- | Access the body of a type lambda term+  SubtermStepTypeLambdaBody |+  -- | Access the term being applied to a type+  SubtermStepTypeApplicationTerm |+  -- | Access the term inside a union injection+  SubtermStepInjectionTerm |+  -- | Access the term inside a wrapped term+  SubtermStepWrappedTerm+  deriving (Eq, Ord, Read, Show)+_SubtermStep = Core.Name "hydra.paths.SubtermStep"+_SubtermStep_annotatedBody = Core.Name "annotatedBody"+_SubtermStep_applicationFunction = Core.Name "applicationFunction"+_SubtermStep_applicationArgument = Core.Name "applicationArgument"+_SubtermStep_lambdaBody = Core.Name "lambdaBody"+_SubtermStep_unionCasesDefault = Core.Name "unionCasesDefault"+_SubtermStep_unionCasesBranch = Core.Name "unionCasesBranch"+_SubtermStep_letBody = Core.Name "letBody"+_SubtermStep_letBinding = Core.Name "letBinding"+_SubtermStep_listElement = Core.Name "listElement"+_SubtermStep_mapKey = Core.Name "mapKey"+_SubtermStep_mapValue = Core.Name "mapValue"+_SubtermStep_optionalTerm = Core.Name "optionalTerm"+_SubtermStep_productTerm = Core.Name "productTerm"+_SubtermStep_recordField = Core.Name "recordField"+_SubtermStep_setElement = Core.Name "setElement"+_SubtermStep_sumTerm = Core.Name "sumTerm"+_SubtermStep_typeLambdaBody = Core.Name "typeLambdaBody"+_SubtermStep_typeApplicationTerm = Core.Name "typeApplicationTerm"+_SubtermStep_injectionTerm = Core.Name "injectionTerm"+_SubtermStep_wrappedTerm = Core.Name "wrappedTerm"+-- | An edge in a subtype graph, connecting two nodes via a path+data SubtypeEdge =+  SubtypeEdge {+    -- | The source node of the edge+    subtypeEdgeSource :: SubtypeNode,+    -- | The subtype path connecting source to target+    subtypeEdgePath :: SubtypePath,+    -- | The target node of the edge+    subtypeEdgeTarget :: SubtypeNode}+  deriving (Eq, Ord, Read, Show)+_SubtypeEdge = Core.Name "hydra.paths.SubtypeEdge"+_SubtypeEdge_source = Core.Name "source"+_SubtypeEdge_path = Core.Name "path"+_SubtypeEdge_target = Core.Name "target"+-- | A graph of subtype nodes and edges, representing type access patterns+data SubtypeGraph =+  SubtypeGraph {+    -- | All nodes in the graph+    subtypeGraphNodes :: [SubtypeNode],+    -- | All edges in the graph+    subtypeGraphEdges :: [SubtypeEdge]}+  deriving (Eq, Ord, Read, Show)+_SubtypeGraph = Core.Name "hydra.paths.SubtypeGraph"+_SubtypeGraph_nodes = Core.Name "nodes"+_SubtypeGraph_edges = Core.Name "edges"+-- | A node in a subtype graph, representing a type or subtype+data SubtypeNode =+  SubtypeNode {+    -- | The qualified name of the type+    subtypeNodeName :: Core.Name,+    -- | A human-readable label for the node+    subtypeNodeLabel :: String,+    -- | A unique identifier for the node+    subtypeNodeId :: String}+  deriving (Eq, Ord, Read, Show)+_SubtypeNode = Core.Name "hydra.paths.SubtypeNode"+_SubtypeNode_name = Core.Name "name"+_SubtypeNode_label = Core.Name "label"+_SubtypeNode_id = Core.Name "id"+-- | A sequence of subtype steps forming a path through a type+newtype SubtypePath =+  SubtypePath {+    unSubtypePath :: [SubtypeStep]}+  deriving (Eq, Ord, Read, Show)+_SubtypePath = Core.Name "hydra.paths.SubtypePath"+-- | A function which maps from a type to a particular immediate subtype+data SubtypeStep =+  -- | Access the body of an annotated type+  SubtypeStepAnnotatedBody |+  -- | Access the function of an application type+  SubtypeStepApplicationFunction |+  -- | Access the argument of an application type+  SubtypeStepApplicationArgument |+  -- | Access the left type of an either type+  SubtypeStepEitherLeft |+  -- | Access the right type of an either type+  SubtypeStepEitherRight |+  -- | Access the body of a universally quantified type+  SubtypeStepForallBody |+  -- | Access the domain type of a function type+  SubtypeStepFunctionDomain |+  -- | Access the codomain type of a function type+  SubtypeStepFunctionCodomain |+  -- | Access the element type of a list type+  SubtypeStepListElement |+  -- | Access the key type of a map type+  SubtypeStepMapKeys |+  -- | Access the value type of a map type+  SubtypeStepMapValues |+  -- | Access the element type of an optional type+  SubtypeStepOptionalElement |+  -- | Access the first type of a pair type+  SubtypeStepPairFirst |+  -- | Access the second type of a pair type+  SubtypeStepPairSecond |+  -- | Access a field type of a record type by field name+  SubtypeStepRecordField Core.Name |+  -- | Access the element type of a set type+  SubtypeStepSetElement |+  -- | Access a field type of a union type by field name+  SubtypeStepUnionField Core.Name |+  -- | Access the type inside a wrapped type+  SubtypeStepWrappedType+  deriving (Eq, Ord, Read, Show)+_SubtypeStep = Core.Name "hydra.paths.SubtypeStep"+_SubtypeStep_annotatedBody = Core.Name "annotatedBody"+_SubtypeStep_applicationFunction = Core.Name "applicationFunction"+_SubtypeStep_applicationArgument = Core.Name "applicationArgument"+_SubtypeStep_eitherLeft = Core.Name "eitherLeft"+_SubtypeStep_eitherRight = Core.Name "eitherRight"+_SubtypeStep_forallBody = Core.Name "forallBody"+_SubtypeStep_functionDomain = Core.Name "functionDomain"+_SubtypeStep_functionCodomain = Core.Name "functionCodomain"+_SubtypeStep_listElement = Core.Name "listElement"+_SubtypeStep_mapKeys = Core.Name "mapKeys"+_SubtypeStep_mapValues = Core.Name "mapValues"+_SubtypeStep_optionalElement = Core.Name "optionalElement"+_SubtypeStep_pairFirst = Core.Name "pairFirst"+_SubtypeStep_pairSecond = Core.Name "pairSecond"+_SubtypeStep_recordField = Core.Name "recordField"+_SubtypeStep_setElement = Core.Name "setElement"+_SubtypeStep_unionField = Core.Name "unionField"+_SubtypeStep_wrappedType = Core.Name "wrappedType"
+ src/main/haskell/Hydra/Predicates.hs view
@@ -0,0 +1,193 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Type and term classification predicates++module Hydra.Predicates where+import qualified Hydra.Arity as Arity+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Dependencies as Dependencies+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Check if a binding needs to be treated as a function+isComplexBinding :: Graph.Graph -> Core.Binding -> Bool+isComplexBinding tc b =++      let term = Core.bindingTerm b+          mts = Core.bindingTypeScheme b+      in (Optionals.cases mts (isComplexTerm tc term) (\ts ->+        let isPolymorphic = Logic.not (Lists.null (Core.typeSchemeVariables ts))+            isNonNullary = Equality.gt (Arity.typeArity (Core.typeSchemeBody ts)) 0+            isComplex = isComplexTerm tc term+        in (Logic.or (Logic.or isPolymorphic isNonNullary) isComplex)))+-- | Check if a term needs to be treated as a function rather than a simple value+isComplexTerm :: Graph.Graph -> Core.Term -> Bool+isComplexTerm tc t =+    case t of+      Core.TermLet _ -> True+      Core.TermTypeApplication _ -> True+      Core.TermTypeLambda _ -> True+      Core.TermVariable v0 -> isComplexVariable tc v0+      _ -> Lists.foldl (\b -> \sub -> Logic.or b (isComplexTerm tc sub)) False (Rewriting.subterms t)+-- | Check if a variable is bound to a complex term+isComplexVariable :: Graph.Graph -> Core.Name -> Bool+isComplexVariable tc name =++      let metaLookup = Maps.lookup name (Graph.graphMetadata tc)+      in (Logic.ifElse (Optionals.isGiven metaLookup) True (Logic.ifElse (Sets.member name (Graph.graphLambdaVariables tc)) True (+        let typeLookup = Maps.lookup name (Graph.graphBoundTypes tc)+        in (Optionals.cases typeLookup (+          let primLookup = Maps.lookup name (Graph.graphPrimitives tc)+          in (Optionals.cases primLookup True (\prim -> Equality.gt (Arity.typeSchemeArity (Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim)))) 0))) (\ts -> Equality.gt (Arity.typeSchemeArity ts) 0)))))+-- | Determines whether a given term is an encoded term (meta-level term)+isEncodedTerm :: Core.Term -> Bool+isEncodedTerm t =+    case (Strip.deannotateTerm t) of+      Core.TermApplication v0 -> isEncodedTerm (Core.applicationFunction v0)+      Core.TermInject v0 -> Equality.equal "hydra.core.Term" (Core.unName (Core.injectionTypeName v0))+      _ -> False+-- | Determines whether a given term is an encoded type+isEncodedType :: Core.Term -> Bool+isEncodedType t =+    case (Strip.deannotateTerm t) of+      Core.TermApplication v0 -> isEncodedType (Core.applicationFunction v0)+      Core.TermInject v0 -> Equality.equal "hydra.core.Type" (Core.unName (Core.injectionTypeName v0))+      _ -> False+-- | Check if a row type represents an enum (all fields are unit-typed)+isEnumRowType :: [Core.FieldType] -> Bool+isEnumRowType rt =+    Lists.foldl Logic.and True (Lists.map (\f -> isUnitType (Strip.deannotateType (Core.fieldTypeType f))) rt)+-- | Check if a type is an enum type+isEnumType :: Core.Type -> Bool+isEnumType typ =+    case (Strip.deannotateType typ) of+      Core.TypeUnion v0 -> isEnumRowType v0+      _ -> False+-- | Check whether a type is a nominal type definition (record, union, wrap, or forall wrapping one). Type aliases (applications, functions, literal types, etc.) return false.+isNominalType :: Core.Type -> Bool+isNominalType typ =+    case (Strip.deannotateType typ) of+      Core.TypeRecord _ -> True+      Core.TypeUnion _ -> True+      Core.TypeWrap _ -> True+      Core.TypeForall v0 -> isNominalType (Core.forallTypeBody v0)+      _ -> False+-- | Check if an element is serializable (no function types in dependencies) (Either version)+isSerializable :: t0 -> Graph.Graph -> Core.Binding -> Either Errors.Error Bool+isSerializable cx graph el =++      let variants =+              \typ -> Lists.map Reflect.typeVariant (Rewriting.foldOverType Coders.TraversalOrderPre (\m -> \t -> Lists.cons t m) [] typ)+      in (Eithers.map (\deps ->+        let allVariants = Sets.fromList (Lists.concat (Lists.map variants (Maps.elems deps)))+        in (Logic.not (Sets.member Variants.TypeVariantFunction allVariants))) (typeDependencies cx graph False Equality.identity (Core.bindingName el)))+-- | Check if a type (by name) is serializable, resolving all type dependencies (Either version)+isSerializableByName :: t0 -> Graph.Graph -> Core.Name -> Either Errors.Error Bool+isSerializableByName cx graph name =++      let variants =+              \typ -> Lists.map Reflect.typeVariant (Rewriting.foldOverType Coders.TraversalOrderPre (\m -> \t -> Lists.cons t m) [] typ)+      in (Eithers.map (\deps ->+        let allVariants = Sets.fromList (Lists.concat (Lists.map variants (Maps.elems deps)))+        in (Logic.not (Sets.member Variants.TypeVariantFunction allVariants))) (typeDependencies cx graph False Equality.identity name))+-- | Check if a type is serializable (no function types in the type itself)+isSerializableType :: Core.Type -> Bool+isSerializableType typ =++      let allVariants =+              Sets.fromList (Lists.map Reflect.typeVariant (Rewriting.foldOverType Coders.TraversalOrderPre (\m -> \t -> Lists.cons t m) [] typ))+      in (Logic.not (Sets.member Variants.TypeVariantFunction allVariants))+-- | Check if a term is trivially cheap (no thunking needed)+isTrivialTerm :: Core.Term -> Bool+isTrivialTerm t =+    case (Strip.deannotateTerm t) of+      Core.TermLiteral _ -> True+      Core.TermVariable v0 -> Equality.equal (Lists.length (Strings.splitOn "." (Core.unName v0))) 1+      Core.TermUnit -> True+      Core.TermApplication v0 ->+        let fun = Core.applicationFunction v0+            arg = Core.applicationArgument v0+        in case fun of+          Core.TermProject _ -> isTrivialTerm arg+          Core.TermUnwrap _ -> isTrivialTerm arg+          _ -> False+      Core.TermOptional v0 -> Optionals.cases v0 True (\inner -> isTrivialTerm inner)+      Core.TermRecord v0 -> Lists.foldl (\acc -> \fld -> Logic.and acc (isTrivialTerm (Core.fieldTerm fld))) True (Core.recordFields v0)+      Core.TermWrap v0 -> isTrivialTerm (Core.wrappedTermBody v0)+      Core.TermTypeApplication v0 -> isTrivialTerm (Core.typeApplicationTermBody v0)+      Core.TermTypeLambda v0 -> isTrivialTerm (Core.typeLambdaBody v0)+      _ -> False+-- | Check whether a type is a type (always true for non-encoded types)+isType :: Core.Type -> Bool+isType t =+    case (Strip.deannotateType t) of+      Core.TypeApplication v0 -> isType (Core.applicationTypeFunction v0)+      Core.TypeForall v0 -> isType (Core.forallTypeBody v0)+      Core.TypeUnion _ -> False+      Core.TypeVariable v0 -> Equality.equal v0 (Core.Name "hydra.core.Type")+      _ -> False+-- | Check whether a term is the unit term+isUnitTerm :: Core.Term -> Bool+isUnitTerm x =+    case x of+      Core.TermUnit -> True+      _ -> False+-- | Check whether a type is the unit type+isUnitType :: Core.Type -> Bool+isUnitType x =+    case x of+      Core.TypeUnit -> True+      _ -> False+-- | Get all type dependencies for a given type name (Either version)+typeDependencies :: t0 -> Graph.Graph -> Bool -> (Core.Type -> Core.Type) -> Core.Name -> Either Errors.Error (M.Map Core.Name Core.Type)+typeDependencies cx graph withSchema transform name =++      let requireType =+              \name2 ->+                let cx1 = cx+                in (Eithers.bind (Lexical.requireBinding graph name2) (\el -> Eithers.bimap (\_e -> Errors.ErrorDecoding _e) (\_a -> _a) (DecodeCore.type_ graph (Core.bindingTerm el))))+          toPair = \name2 -> Eithers.map (\typ -> (name2, (transform typ))) (requireType name2)+          deps =+                  \seeds -> \names -> Logic.ifElse (Sets.null seeds) (Right names) (Eithers.bind (Eithers.mapList toPair (Sets.toList seeds)) (\pairs ->+                    let newNames = Maps.union names (Maps.fromList pairs)+                        refs =+                                Lists.foldl Sets.union Sets.empty (Lists.map (\pair -> Dependencies.typeDependencyNames withSchema (Pairs.second pair)) pairs)+                        visited = Sets.fromList (Maps.keys names)+                        newSeeds = Sets.difference refs visited+                    in (deps newSeeds newNames)))+      in (deps (Sets.singleton name) Maps.empty)
+ src/main/haskell/Hydra/Query.hs view
@@ -0,0 +1,206 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A model for language-agnostic graph pattern queries++module Hydra.Query where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | One of several comparison operators+data ComparisonConstraint =+  ComparisonConstraintEqual |+  ComparisonConstraintNotEqual |+  ComparisonConstraintLessThan |+  ComparisonConstraintGreaterThan |+  ComparisonConstraintLessThanOrEqual |+  ComparisonConstraintGreaterThanOrEqual+  deriving (Eq, Ord, Read, Show)+_ComparisonConstraint = Core.Name "hydra.query.ComparisonConstraint"+_ComparisonConstraint_equal = Core.Name "equal"+_ComparisonConstraint_notEqual = Core.Name "notEqual"+_ComparisonConstraint_lessThan = Core.Name "lessThan"+_ComparisonConstraint_greaterThan = Core.Name "greaterThan"+_ComparisonConstraint_lessThanOrEqual = Core.Name "lessThanOrEqual"+_ComparisonConstraint_greaterThanOrEqual = Core.Name "greaterThanOrEqual"+-- | An abstract edge based on a record type+data Edge =+  Edge {+    -- | The name of a record type, for which the edge also specifies an out- and an in- projection+    edgeType :: Core.Name,+    -- | The field representing the out-projection of the edge. Defaults to 'out'.+    edgeOut :: (Maybe Core.Name),+    -- | The field representing the in-projection of the edge. Defaults to 'in'.+    edgeIn :: (Maybe Core.Name)}+  deriving (Eq, Ord, Read, Show)+_Edge = Core.Name "hydra.query.Edge"+_Edge_type = Core.Name "type"+_Edge_out = Core.Name "out"+_Edge_in = Core.Name "in"+-- | A query pattern which matches within a designated component subgraph+data GraphPattern =+  GraphPattern {+    -- | The name of the component graph+    graphPatternGraph :: Core.Name,+    -- | The patterns to match within the subgraph+    graphPatternPatterns :: [Pattern]}+  deriving (Eq, Ord, Read, Show)+_GraphPattern = Core.Name "hydra.query.GraphPattern"+_GraphPattern_graph = Core.Name "graph"+_GraphPattern_patterns = Core.Name "patterns"+-- | A node in a query expression; it may be a term, a variable, or a wildcard+data Node =+  -- | A graph term; an expression which is valid in the graph being matched+  NodeTerm Core.Term |+  -- | A query variable, not to be confused with a variable term+  NodeVariable Variable |+  -- | An anonymous variable which we do not care to join across patterns+  NodeWildcard+  deriving (Eq, Ord, Read, Show)+_Node = Core.Name "hydra.query.Node"+_Node_term = Core.Name "term"+_Node_variable = Core.Name "variable"+_Node_wildcard = Core.Name "wildcard"+-- | A query path+data Path =+  -- | A path given by a single step+  PathStep Step |+  -- | A path given by a regular expression quantifier applied to another path+  PathRegex RegexSequence |+  -- | A path given by the inverse of another path+  PathInverse Path+  deriving (Eq, Ord, Read, Show)+_Path = Core.Name "hydra.query.Path"+_Path_step = Core.Name "step"+_Path_regex = Core.Name "regex"+_Path_inverse = Core.Name "inverse"+-- | A declared equivalence between two abstract paths in a graph+data PathEquation =+  PathEquation {+    -- | The left-hand side of the equation+    pathEquationLeft :: Path,+    -- | The right-hand side of the equation+    pathEquationRight :: Path}+  deriving (Eq, Ord, Read, Show)+_PathEquation = Core.Name "hydra.query.PathEquation"+_PathEquation_left = Core.Name "left"+_PathEquation_right = Core.Name "right"+-- | A query pattern+data Pattern =+  -- | A subject/predicate/object pattern+  PatternTriple TriplePattern |+  -- | The negation of another pattern+  PatternNegation Pattern |+  -- | The conjunction ('and') of several other patterns+  PatternConjunction [Pattern] |+  -- | The disjunction (inclusive 'or') of several other patterns+  PatternDisjunction [Pattern] |+  -- | A pattern which matches within a named subgraph+  PatternGraph GraphPattern+  deriving (Eq, Ord, Read, Show)+_Pattern = Core.Name "hydra.query.Pattern"+_Pattern_triple = Core.Name "triple"+_Pattern_negation = Core.Name "negation"+_Pattern_conjunction = Core.Name "conjunction"+_Pattern_disjunction = Core.Name "disjunction"+_Pattern_graph = Core.Name "graph"+-- | A pattern which, if it matches in a given graph, implies that another pattern must also match. Query variables are shared between the two patterns.+data PatternImplication =+  PatternImplication {+    -- | The pattern which, if it matches, triggers the constraint+    patternImplicationAntecedent :: Pattern,+    -- | The pattern which must also match when the antecedent matches+    patternImplicationConsequent :: Pattern}+  deriving (Eq, Ord, Read, Show)+_PatternImplication = Core.Name "hydra.query.PatternImplication"+_PatternImplication_antecedent = Core.Name "antecedent"+_PatternImplication_consequent = Core.Name "consequent"+-- | A SELECT-style graph pattern matching query+data Query =+  Query {+    -- | The variables selected by the query+    queryVariables :: [Variable],+    -- | The patterns to be matched+    queryPatterns :: [Pattern]}+  deriving (Eq, Ord, Read, Show)+_Query = Core.Name "hydra.query.Query"+_Query_variables = Core.Name "variables"+_Query_patterns = Core.Name "patterns"+-- | A range from min to max, inclusive+data Range =+  Range {+    -- | The minimum value (inclusive)+    rangeMin :: Int,+    -- | The maximum value (inclusive)+    rangeMax :: Int}+  deriving (Eq, Ord, Read, Show)+_Range = Core.Name "hydra.query.Range"+_Range_min = Core.Name "min"+_Range_max = Core.Name "max"+-- | A regular expression quantifier+data RegexQuantifier =+  -- | No quantifier; matches a single occurrence+  RegexQuantifierOne |+  -- | The ? quanifier; matches zero or one occurrence+  RegexQuantifierZeroOrOne |+  -- | The * quantifier; matches any number of occurrences+  RegexQuantifierZeroOrMore |+  -- | The + quantifier; matches one or more occurrences+  RegexQuantifierOneOrMore |+  -- | The {n} quantifier; matches exactly n occurrences+  RegexQuantifierExactly Int |+  -- | The {n,} quantifier; matches at least n occurrences+  RegexQuantifierAtLeast Int |+  -- | The {n, m} quantifier; matches between n and m (inclusive) occurrences+  RegexQuantifierRange Range+  deriving (Eq, Ord, Read, Show)+_RegexQuantifier = Core.Name "hydra.query.RegexQuantifier"+_RegexQuantifier_one = Core.Name "one"+_RegexQuantifier_zeroOrOne = Core.Name "zeroOrOne"+_RegexQuantifier_zeroOrMore = Core.Name "zeroOrMore"+_RegexQuantifier_oneOrMore = Core.Name "oneOrMore"+_RegexQuantifier_exactly = Core.Name "exactly"+_RegexQuantifier_atLeast = Core.Name "atLeast"+_RegexQuantifier_range = Core.Name "range"+-- | A path with a regex quantifier+data RegexSequence =+  RegexSequence {+    -- | The path to which the quantifier applies+    regexSequencePath :: Path,+    -- | The quantifier+    regexSequenceQuantifier :: RegexQuantifier}+  deriving (Eq, Ord, Read, Show)+_RegexSequence = Core.Name "hydra.query.RegexSequence"+_RegexSequence_path = Core.Name "path"+_RegexSequence_quantifier = Core.Name "quantifier"+-- | An atomic function as part of a query. When applied to a graph, steps are typed by function types.+data Step =+  -- | An out-to-in traversal of an abstract edge+  StepEdge Edge |+  -- | A projection from a record through one of its fields+  StepProject Core.Projection |+  -- | A comparison of two terms+  StepCompare ComparisonConstraint+  deriving (Eq, Ord, Read, Show)+_Step = Core.Name "hydra.query.Step"+_Step_edge = Core.Name "edge"+_Step_project = Core.Name "project"+_Step_compare = Core.Name "compare"+-- | A subject/predicate/object pattern+data TriplePattern =+  TriplePattern {+    -- | The subject of the pattern+    triplePatternSubject :: Node,+    -- | The predicate (property) of the pattern+    triplePatternPredicate :: Path,+    -- | The object of the pattern+    triplePatternObject :: Node}+  deriving (Eq, Ord, Read, Show)+_TriplePattern = Core.Name "hydra.query.TriplePattern"+_TriplePattern_subject = Core.Name "subject"+_TriplePattern_predicate = Core.Name "predicate"+_TriplePattern_object = Core.Name "object"+-- | A query variable+newtype Variable =+  Variable {+    unVariable :: String}+  deriving (Eq, Ord, Read, Show)+_Variable = Core.Name "hydra.query.Variable"
+ src/main/haskell/Hydra/Reduction.hs view
@@ -0,0 +1,601 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Functions for reducing terms and types, i.e. performing computations.++module Hydra.Reduction where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Arity as Arity+import qualified Hydra.Ast as Ast+import qualified Hydra.Checking as Checking+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Error.Checking as ErrorChecking+import qualified Hydra.Error.Core as ErrorCore+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.Hoisting as Hoisting+import qualified Hydra.Inference as Inference+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Resolution as Resolution+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Strip as Strip+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Alpha convert a variable in a term+alphaConvert :: Core.Name -> Core.Name -> Core.Term -> Core.Term+alphaConvert vold vnew term = Variables.replaceFreeTermVariable vold (Core.TermVariable vnew) term+-- | Eagerly beta-reduce a type by substituting type arguments into type lambdas+betaReduceType :: t0 -> Graph.Graph -> Core.Type -> Either Errors.Error Core.Type+betaReduceType cx graph typ =++      let reduceApp =+              \app ->+                let lhs = Core.applicationTypeFunction app+                    rhs = Core.applicationTypeArgument app+                in case lhs of+                  Core.TypeAnnotated v0 -> Eithers.bind (reduceApp (Core.ApplicationType {+                    Core.applicationTypeFunction = (Core.annotatedTypeBody v0),+                    Core.applicationTypeArgument = rhs})) (\a -> Right (Core.TypeAnnotated (Core.AnnotatedType {+                    Core.annotatedTypeBody = a,+                    Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)})))+                  Core.TypeForall v0 -> betaReduceType cx graph (Variables.replaceFreeTypeVariable (Core.forallTypeParameter v0) rhs (Core.forallTypeBody v0))+                  Core.TypeVariable v0 -> Eithers.bind (Resolution.requireType cx graph v0) (\t_ -> betaReduceType cx graph (Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = t_,+                    Core.applicationTypeArgument = rhs})))+          mapExpr =+                  \recurse -> \t ->+                    let findApp =+                            \r -> case r of+                              Core.TypeApplication v0 -> reduceApp v0+                              _ -> Right r+                    in (Eithers.bind (recurse t) (\r -> findApp r))+      in (Rewriting.rewriteTypeM mapExpr typ)+-- | Apply the special rules:+-- |     ((\x.e1) e2) == e1, where x does not appear free in e1+-- |   and+-- |      ((\x.e1) e2) = e1[x/e2]+-- | These are both limited forms of beta reduction which help to "clean up" a term without fully evaluating it.+contractTerm :: Core.Term -> Core.Term+contractTerm term =++      let rewrite =+              \recurse -> \t ->+                let rec = recurse t+                in case rec of+                  Core.TermApplication v0 ->+                    let lhs = Core.applicationFunction v0+                        rhs = Core.applicationArgument v0+                    in case (Strip.deannotateTerm lhs) of+                      Core.TermLambda v1 ->+                        let v = Core.lambdaParameter v1+                            body = Core.lambdaBody v1+                        in (Logic.ifElse (Variables.isFreeVariableInTerm v body) body (Variables.replaceFreeTermVariable v rhs body))+                      _ -> rec+                  _ -> rec+      in (Rewriting.rewriteTerm rewrite term)+-- | Compile-time flag controlling whether primitive invocations are counted during evaluation. For demo and instrumentation purposes.+countPrimitiveInvocations :: Bool+countPrimitiveInvocations = True+-- | Recursively transform terms to eliminate partial application, e.g. 'add 42' becomes '\x.add 42 x'. Uses the Graph to look up types for arity calculation. Bare primitives and variables are NOT expanded; eliminations and partial applications are. This version properly tracks the Graph through nested scopes.+etaExpandTerm :: Graph.Graph -> Core.Term -> Core.Term+etaExpandTerm tx0 term0 =++      let primTypes =+              Maps.fromList (Lists.map (\_gpt_p -> (+                Packaging.primitiveDefinitionName (Graph.primitiveDefinition _gpt_p),+                (Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _gpt_p))))) (Maps.elems (Graph.graphPrimitives tx0)))+          termArityWithContext =+                  \tx -> \term -> case term of+                    Core.TermAnnotated v0 -> termArityWithContext tx (Core.annotatedTermBody v0)+                    Core.TermApplication v0 -> Math.sub (termArityWithContext tx (Core.applicationFunction v0)) 1+                    Core.TermCases _ -> 1+                    Core.TermLambda _ -> 0+                    Core.TermProject _ -> 1+                    Core.TermUnwrap _ -> 1+                    Core.TermLet v0 -> termArityWithContext (Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) tx v0) (Core.letBody v0)+                    Core.TermTypeLambda v0 -> termArityWithContext (Scoping.extendGraphForTypeLambda tx v0) (Core.typeLambdaBody v0)+                    Core.TermTypeApplication v0 -> termArityWithContext tx (Core.typeApplicationTermBody v0)+                    Core.TermVariable v0 -> Optionals.cases (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx))) (Optionals.cases (Maps.lookup v0 primTypes) 0 Arity.typeSchemeArity) Arity.typeArity+                    _ -> 0+          domainTypes =+                  \n -> \mt -> Logic.ifElse (Equality.lte n 0) [] (Optionals.cases mt (Lists.map (\_ -> Nothing) (Math.range 1 n)) (\typ -> case typ of+                    Core.TypeFunction v0 -> Lists.cons (Just (Core.functionTypeDomain v0)) (domainTypes (Math.sub n 1) (Just (Core.functionTypeCodomain v0)))+                    Core.TypeAnnotated v0 -> domainTypes n (Just (Core.annotatedTypeBody v0))+                    Core.TypeApplication v0 -> domainTypes n (Just (Core.applicationTypeFunction v0))+                    Core.TypeForall _ -> Lists.map (\_2 -> Nothing) (Math.range 1 n)+                    _ -> Lists.map (\_ -> Nothing) (Math.range 1 n)))+          peelFunctionDomains =+                  \mtyp -> \n -> Logic.ifElse (Equality.lte n 0) mtyp (Optionals.cases mtyp Nothing (\typ -> case typ of+                    Core.TypeFunction v0 -> peelFunctionDomains (Just (Core.functionTypeCodomain v0)) (Math.sub n 1)+                    Core.TypeAnnotated v0 -> peelFunctionDomains (Just (Core.annotatedTypeBody v0)) n+                    Core.TypeApplication v0 -> peelFunctionDomains (Just (Core.applicationTypeFunction v0)) n+                    Core.TypeForall _ -> Nothing+                    _ -> Nothing))+          expand =+                  \alwaysPad -> \args -> \arity -> \headTyp -> \head ->+                    let applied =+                            Lists.foldl (\lhs -> \arg -> Core.TermApplication (Core.Application {+                              Core.applicationFunction = lhs,+                              Core.applicationArgument = arg})) head args+                        numArgs = Lists.length args+                        needed = Math.sub arity numArgs+                    in (Logic.ifElse (Logic.and (Equality.gt needed 0) (Logic.or alwaysPad (Equality.gt numArgs 0))) (+                      let indices = Math.range 1 needed+                          remainingType = peelFunctionDomains headTyp numArgs+                          domains = domainTypes needed remainingType+                          codomainType = peelFunctionDomains remainingType needed+                          fullyAppliedRaw =+                                  Lists.foldl (\body -> \i ->+                                    let vn = Core.Name (Strings.cat2 "v" (Literals.showInt32 i))+                                    in (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = body,+                                      Core.applicationArgument = (Core.TermVariable vn)}))) applied indices+                          fullyApplied =+                                  Optionals.cases codomainType fullyAppliedRaw (\ct -> Core.TermAnnotated (Core.AnnotatedTerm {+                                    Core.annotatedTermBody = fullyAppliedRaw,+                                    Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.singleton (Core.Name "type") (EncodeCore.type_ ct)))}))+                          indexedDomains = Lists.zip indices domains+                      in (Lists.foldl (\body -> \idPair ->+                        let i = Pairs.first idPair+                            dom = Pairs.second idPair+                            vn = Core.Name (Strings.cat2 "v" (Literals.showInt32 i))+                        in (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = vn,+                          Core.lambdaDomain = dom,+                          Core.lambdaBody = body}))) fullyApplied (Lists.reverse indexedDomains))) applied)+          rewriteWithArgs =+                  \args -> \tx -> \term ->+                    let recurse = \tx1 -> \term1 -> rewriteWithArgs [] tx1 term1+                        termHeadType =+                                \tx2 -> \trm2 -> case trm2 of+                                  Core.TermAnnotated v0 -> termHeadType tx2 (Core.annotatedTermBody v0)+                                  Core.TermLambda _ -> Nothing+                                  Core.TermCases _ -> Nothing+                                  Core.TermProject _ -> Nothing+                                  Core.TermUnwrap _ -> Nothing+                                  Core.TermLet v0 -> termHeadType (Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) tx2 v0) (Core.letBody v0)+                                  Core.TermTypeLambda v0 -> termHeadType (Scoping.extendGraphForTypeLambda tx2 v0) (Core.typeLambdaBody v0)+                                  Core.TermTypeApplication v0 -> Optionals.bind (termHeadType tx2 (Core.typeApplicationTermBody v0)) (\htyp2 -> case htyp2 of+                                    Core.TypeForall v1 -> Just (Variables.replaceFreeTypeVariable (Core.forallTypeParameter v1) (Core.typeApplicationTermType v0) (Core.forallTypeBody v1))+                                    _ -> Just htyp2)+                                  Core.TermVariable v0 -> Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx2))+                                  _ -> Nothing+                        afterRecursion =+                                \trm ->+                                  let arity = termArityWithContext tx trm+                                      hType = termHeadType tx trm+                                  in (expand False args arity hType trm)+                        forField =+                                \f -> Core.Field {+                                  Core.fieldName = (Core.fieldName f),+                                  Core.fieldTerm = (recurse tx (Core.fieldTerm f))}+                        forCaseBranch =+                                \f ->+                                  let branchBody = recurse tx (Core.caseAlternativeHandler f)+                                      arty = termArityWithContext tx branchBody+                                      branchHType = termHeadType tx branchBody+                                  in Core.CaseAlternative {+                                    Core.caseAlternativeName = (Core.caseAlternativeName f),+                                    Core.caseAlternativeHandler = (expand True [] arty branchHType branchBody)}+                        forMap =+                                \mp ->+                                  let forPair = \pr -> (recurse tx (Pairs.first pr), (recurse tx (Pairs.second pr)))+                                  in (Maps.fromList (Lists.map forPair (Maps.toList mp)))+                    in case term of+                      Core.TermAnnotated v0 -> afterRecursion (Core.TermAnnotated (Core.AnnotatedTerm {+                        Core.annotatedTermBody = (recurse tx (Core.annotatedTermBody v0)),+                        Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)}))+                      Core.TermApplication v0 ->+                        let rhs = rewriteWithArgs [] tx (Core.applicationArgument v0)+                        in (rewriteWithArgs (Lists.cons rhs args) tx (Core.applicationFunction v0))+                      Core.TermEither v0 -> afterRecursion (Core.TermEither (Eithers.either (\l -> Left (recurse tx l)) (\r -> Right (recurse tx r)) v0))+                      Core.TermCases v0 ->+                        let newCs =+                                Core.CaseStatement {+                                  Core.caseStatementTypeName = (Core.caseStatementTypeName v0),+                                  Core.caseStatementDefault = (Optionals.map (\t1 -> recurse tx t1) (Core.caseStatementDefault v0)),+                                  Core.caseStatementCases = (Lists.map forCaseBranch (Core.caseStatementCases v0))}+                            elimTerm = Core.TermCases newCs+                            elimHeadType =+                                    Just (Core.TypeFunction (Core.FunctionType {+                                      Core.functionTypeDomain = (Core.TypeVariable (Core.caseStatementTypeName v0)),+                                      Core.functionTypeCodomain = Core.TypeUnit}))+                        in (expand True args 1 elimHeadType elimTerm)+                      Core.TermProject v0 -> expand False args 1 Nothing (Core.TermProject v0)+                      Core.TermUnwrap v0 -> expand False args 1 Nothing (Core.TermUnwrap v0)+                      Core.TermLambda v0 ->+                        let tx1 = Scoping.extendGraphForLambda tx v0+                            body = rewriteWithArgs [] tx1 (Core.lambdaBody v0)+                            result =+                                    Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.lambdaParameter v0),+                                      Core.lambdaDomain = (Core.lambdaDomain v0),+                                      Core.lambdaBody = body})+                            arty = termArityWithContext tx result+                        in (expand False args arty Nothing result)+                      Core.TermLet v0 ->+                        let tx1 = Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) tx v0+                            mapBinding =+                                    \b -> Core.Binding {+                                      Core.bindingName = (Core.bindingName b),+                                      Core.bindingTerm = (rewriteWithArgs [] tx1 (Core.bindingTerm b)),+                                      Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                            result =+                                    Core.TermLet (Core.Let {+                                      Core.letBindings = (Lists.map mapBinding (Core.letBindings v0)),+                                      Core.letBody = (rewriteWithArgs [] tx1 (Core.letBody v0))})+                        in (afterRecursion result)+                      Core.TermList v0 -> afterRecursion (Core.TermList (Lists.map (\el -> recurse tx el) v0))+                      Core.TermLiteral v0 -> Core.TermLiteral v0+                      Core.TermMap v0 -> afterRecursion (Core.TermMap (forMap v0))+                      Core.TermOptional v0 -> afterRecursion (Core.TermOptional (Optionals.map (\v -> recurse tx v) v0))+                      Core.TermPair v0 -> afterRecursion (Core.TermPair (recurse tx (Pairs.first v0), (recurse tx (Pairs.second v0))))+                      Core.TermRecord v0 -> afterRecursion (Core.TermRecord (Core.Record {+                        Core.recordTypeName = (Core.recordTypeName v0),+                        Core.recordFields = (Lists.map forField (Core.recordFields v0))}))+                      Core.TermSet v0 -> afterRecursion (Core.TermSet (Sets.fromList (Lists.map (\el -> recurse tx el) (Sets.toList v0))))+                      Core.TermTypeApplication v0 ->+                        let gatherTypeApps =+                                \acc -> \trm -> case (Strip.deannotateTerm trm) of+                                  Core.TermTypeApplication v1 -> gatherTypeApps (Lists.cons (Core.typeApplicationTermType v1) acc) (Core.typeApplicationTermBody v1)+                                  _ -> (trm, acc)+                            gathered = gatherTypeApps [+                                  Core.typeApplicationTermType v0] (Core.typeApplicationTermBody v0)+                            innermost = Pairs.first gathered+                            tApps = Pairs.second gathered+                        in case (Strip.deannotateTerm innermost) of+                          Core.TermCases v1 ->+                            let newCs =+                                    Core.CaseStatement {+                                      Core.caseStatementTypeName = (Core.caseStatementTypeName v1),+                                      Core.caseStatementDefault = (Optionals.map (\t1 -> recurse tx t1) (Core.caseStatementDefault v1)),+                                      Core.caseStatementCases = (Lists.map forCaseBranch (Core.caseStatementCases v1))}+                                casesWithTypeApps =+                                        Lists.foldl (\trm -> \t -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                                          Core.typeApplicationTermBody = trm,+                                          Core.typeApplicationTermType = t})) (Core.TermCases newCs) tApps+                                elimHeadTypeTyped =+                                        Just (Core.TypeFunction (Core.FunctionType {+                                          Core.functionTypeDomain = (Resolution.nominalApplication (Core.caseStatementTypeName v1) tApps),+                                          Core.functionTypeCodomain = Core.TypeUnit}))+                            in (expand True args 1 elimHeadTypeTyped casesWithTypeApps)+                          _ -> afterRecursion (Core.TermTypeApplication (Core.TypeApplicationTerm {+                            Core.typeApplicationTermBody = (recurse tx (Core.typeApplicationTermBody v0)),+                            Core.typeApplicationTermType = (Core.typeApplicationTermType v0)}))+                      Core.TermTypeLambda v0 ->+                        let tx1 = Scoping.extendGraphForTypeLambda tx v0+                            result =+                                    Core.TermTypeLambda (Core.TypeLambda {+                                      Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+                                      Core.typeLambdaBody = (rewriteWithArgs [] tx1 (Core.typeLambdaBody v0))})+                        in (afterRecursion result)+                      Core.TermInject v0 -> afterRecursion (Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.injectionTypeName v0),+                        Core.injectionField = (forField (Core.injectionField v0))}))+                      Core.TermUnit -> Core.TermUnit+                      Core.TermVariable v0 ->+                        let arty = termArityWithContext tx term+                            varType = Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx))+                        in (expand False args arty varType term)+                      Core.TermWrap v0 -> afterRecursion (Core.TermWrap (Core.WrappedTerm {+                        Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0),+                        Core.wrappedTermBody = (recurse tx (Core.wrappedTermBody v0))}))+      in (contractTerm (rewriteWithArgs [] tx0 term0))+-- | Recursively transform arbitrary terms like 'add 42' into terms like '\x.add 42 x', eliminating partial application. Variable references are not expanded. This is useful for targets like Python with weaker support for currying than Hydra or Haskell. Note: this is a "trusty" function which assumes the graph is well-formed, i.e. no dangling references. It also assumes that type inference has already been performed. After eta expansion, type inference needs to be performed again, as new, untyped lambdas may have been added.+etaExpandTypedTerm :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error Core.Term+etaExpandTypedTerm cx tx0 term0 =++      let rewrite =+              \topLevel -> \forced -> \typeArgs -> \recurse -> \tx -> \term ->+                let rewriteSpine =+                        \term2 -> case term2 of+                          Core.TermAnnotated v0 -> Eithers.bind (rewriteSpine (Core.annotatedTermBody v0)) (\body ->+                            let ann = Core.annotatedTermAnnotation v0+                            in (Right (Core.TermAnnotated (Core.AnnotatedTerm {+                              Core.annotatedTermBody = body,+                              Core.annotatedTermAnnotation = ann}))))+                          Core.TermApplication v0 ->+                            let l = Logic.ifElse False [+                                  Core.TypeLiteral Core.LiteralTypeString] []+                            in (Eithers.bind (rewriteSpine (Core.applicationFunction v0)) (\lhs -> Eithers.bind (rewrite True False l recurse tx (Core.applicationArgument v0)) (\rhs -> Right (Core.TermApplication (Core.Application {+                              Core.applicationFunction = lhs,+                              Core.applicationArgument = rhs})))))+                          Core.TermTypeApplication v0 -> Eithers.bind (rewriteSpine (Core.typeApplicationTermBody v0)) (\body ->+                            let typ = Core.typeApplicationTermType v0+                            in (Right (Core.TermTypeApplication (Core.TypeApplicationTerm {+                              Core.typeApplicationTermBody = body,+                              Core.typeApplicationTermType = typ}))))+                          _ -> rewrite False False [] recurse tx term2+                    arityOf =+                            \tx2 -> \term2 ->+                              let dflt = Eithers.map (\_tc -> Arity.typeArity (Pairs.first _tc)) (Checking.typeOf cx tx2 [] term2)+                              in case term2 of+                                Core.TermAnnotated v0 -> arityOf tx2 (Core.annotatedTermBody v0)+                                Core.TermCases _ -> Right 1+                                Core.TermProject _ -> Right 1+                                Core.TermUnwrap _ -> Right 1+                                Core.TermLambda v0 ->+                                  let txl = Scoping.extendGraphForLambda tx2 v0+                                  in (arityOf txl (Core.lambdaBody v0))+                                Core.TermLet v0 ->+                                  let txl = Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) tx2 v0+                                  in (arityOf txl (Core.letBody v0))+                                Core.TermTypeApplication v0 -> arityOf tx2 (Core.typeApplicationTermBody v0)+                                Core.TermTypeLambda v0 ->+                                  let txt = Scoping.extendGraphForTypeLambda tx2 v0+                                  in (arityOf txt (Core.typeLambdaBody v0))+                                Core.TermVariable v0 -> Optionals.cases (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx2))) (Eithers.map (\_tc -> Arity.typeArity (Pairs.first _tc)) (Checking.typeOf cx tx2 [] (Core.TermVariable v0))) (\t -> Right (Arity.typeArity t))+                                _ -> dflt+                    extraVariables = \n -> Lists.map (\i -> Core.Name (Strings.cat2 "v" (Literals.showInt32 i))) (Math.range 1 n)+                    pad =+                            \vars -> \body -> Optionals.cases (Lists.uncons vars) body (\uc ->+                              let v0 = Pairs.first uc+                                  vrest = Pairs.second uc+                              in (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = v0,+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (pad vrest (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = body,+                                  Core.applicationArgument = (Core.TermVariable v0)})))})))+                    padn = \n -> \body -> pad (extraVariables n) body+                    unwind =+                            \term2 -> Lists.foldl (\e -> \t -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                              Core.typeApplicationTermBody = e,+                              Core.typeApplicationTermType = t})) term2 typeArgs+                    forceExpansion =+                            \t -> Eithers.bind (Checking.typeOf cx tx [] t) (\typCx ->+                              let arity = Arity.typeArity (Pairs.first typCx)+                              in (Right (padn arity (unwind t))))+                    recurseOrForce = \term2 -> Logic.ifElse forced (forceExpansion term2) (recurse tx (unwind term2))+                    forCase =+                            \f -> Eithers.bind (rewrite False True [] recurse tx (Core.caseAlternativeHandler f)) (\r -> Right (Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.caseAlternativeName f),+                              Core.caseAlternativeHandler = r}))+                    forCaseStatement =+                            \cs ->+                              let tname = Core.caseStatementTypeName cs+                                  dflt = Core.caseStatementDefault cs+                                  csCases = Core.caseStatementCases cs+                              in (Eithers.bind (Eithers.mapOptional (rewrite False False [] recurse tx) dflt) (\rdflt -> Eithers.bind (Eithers.mapList forCase csCases) (\rcases -> Right (Core.TermCases (Core.CaseStatement {+                                Core.caseStatementTypeName = tname,+                                Core.caseStatementDefault = rdflt,+                                Core.caseStatementCases = rcases})))))+                    forCases =+                            \cs -> Eithers.bind (Eithers.map unwind (forCaseStatement cs)) (\base -> Right (Logic.ifElse (Logic.or topLevel forced) (padn 1 base) base))+                    forNullaryElim =+                            \elimTerm ->+                              let base = unwind elimTerm+                              in (Logic.ifElse (Logic.or topLevel forced) (padn 1 base) base)+                in case term of+                  Core.TermApplication v0 ->+                    let lhs = Core.applicationFunction v0+                        rhs = Core.applicationArgument v0+                    in (Eithers.bind (rewrite True False [] recurse tx rhs) (\rhs2 -> Eithers.bind (arityOf tx lhs) (\lhsarity -> Eithers.bind (rewriteSpine lhs) (\lhs2 ->+                      let a2 =+                              Core.TermApplication (Core.Application {+                                Core.applicationFunction = lhs2,+                                Core.applicationArgument = rhs2})+                      in (Right (Logic.ifElse (Equality.gt lhsarity 1) (padn (Math.sub lhsarity 1) a2) a2))))))+                  Core.TermCases v0 -> forCases v0+                  Core.TermProject v0 -> Right (forNullaryElim (Core.TermProject v0))+                  Core.TermUnwrap v0 -> Right (forNullaryElim (Core.TermUnwrap v0))+                  Core.TermLambda v0 ->+                    let txl = Scoping.extendGraphForLambda tx v0+                    in (Eithers.map unwind (recurse txl term))+                  Core.TermLet v0 ->+                    let txlt = Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) tx v0+                    in (recurse txlt term)+                  Core.TermTypeApplication v0 -> rewrite topLevel forced (Lists.cons (Core.typeApplicationTermType v0) typeArgs) recurse tx (Core.typeApplicationTermBody v0)+                  Core.TermTypeLambda v0 ->+                    let txt = Scoping.extendGraphForTypeLambda tx v0+                    in (recurse txt term)+                  _ -> recurseOrForce term+      in (Rewriting.rewriteTermWithContextM (rewrite True False []) tx0 term0)+-- | Calculate the arity for eta expansion Note: this is a "trusty" function which assumes the graph is well-formed, i.e. no dangling references.+etaExpansionArity :: Graph.Graph -> Core.Term -> Int+etaExpansionArity graph term =+    case term of+      Core.TermAnnotated v0 -> etaExpansionArity graph (Core.annotatedTermBody v0)+      Core.TermApplication v0 -> Math.sub (etaExpansionArity graph (Core.applicationFunction v0)) 1+      Core.TermCases _ -> 1+      Core.TermLambda _ -> 0+      Core.TermProject _ -> 1+      Core.TermUnwrap _ -> 1+      Core.TermTypeLambda v0 -> etaExpansionArity graph (Core.typeLambdaBody v0)+      Core.TermTypeApplication v0 -> etaExpansionArity graph (Core.typeApplicationTermBody v0)+      Core.TermVariable v0 -> Optionals.cases (Optionals.bind (Lexical.lookupBinding graph v0) (\b -> Core.bindingTypeScheme b)) 0 (\ts -> Arity.typeArity (Core.typeSchemeBody ts))+      _ -> 0+-- | Eta-reduce a term by removing redundant lambda abstractions+etaReduceTerm :: Core.Term -> Core.Term+etaReduceTerm term =++      let noChange = term+          reduceLambda =+                  \l ->+                    let v = Core.lambdaParameter l+                        d = Core.lambdaDomain l+                        body = Core.lambdaBody l+                    in case (etaReduceTerm body) of+                      Core.TermAnnotated v0 -> reduceLambda (Core.Lambda {+                        Core.lambdaParameter = v,+                        Core.lambdaDomain = d,+                        Core.lambdaBody = (Core.annotatedTermBody v0)})+                      Core.TermApplication v0 ->+                        let lhs = Core.applicationFunction v0+                            rhs = Core.applicationArgument v0+                        in case (etaReduceTerm rhs) of+                          Core.TermAnnotated v1 -> reduceLambda (Core.Lambda {+                            Core.lambdaParameter = v,+                            Core.lambdaDomain = d,+                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = lhs,+                              Core.applicationArgument = (Core.annotatedTermBody v1)}))})+                          Core.TermVariable v1 -> Logic.ifElse (Logic.and (Equality.equal (Core.unName v) (Core.unName v1)) (Logic.not (Variables.isFreeVariableInTerm v lhs))) (etaReduceTerm lhs) noChange+                          _ -> noChange+                      _ -> noChange+      in case term of+        Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {+          Core.annotatedTermBody = (etaReduceTerm (Core.annotatedTermBody v0)),+          Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})+        Core.TermLambda v0 -> reduceLambda v0+        _ -> noChange+-- | A term evaluation function which is alternatively lazy or eager+reduceTerm :: Typing.InferenceContext -> Graph.Graph -> Bool -> Core.Term -> Either Errors.Error Core.Term+reduceTerm cx graph eager term =++      let reduce = \eager2 -> reduceTerm cx graph eager2+          doRecurse =+                  \eager2 -> \term2 ->+                    let isNonLambdaTerm =+                            case term2 of+                              Core.TermLambda _ -> False+                              Core.TermLet _ -> False+                              _ -> True+                    in (Logic.and eager2 isNonLambdaTerm)+          reduceArg = \eager2 -> \arg -> Logic.ifElse eager2 (Right arg) (reduce False arg)+          applyToArguments =+                  \fun -> \args -> Optionals.cases (Lists.uncons args) fun (\uc -> applyToArguments (Core.TermApplication (Core.Application {+                    Core.applicationFunction = fun,+                    Core.applicationArgument = (Pairs.first uc)})) (Pairs.second uc))+          mapErrorToString = \e -> Errors.ErrorOther (Errors.OtherError (ShowErrors.error e))+          applyProjection =+                  \proj -> \reducedArg -> Eithers.bind (ExtractCore.record (Core.projectionTypeName proj) graph (Strip.deannotateTerm reducedArg)) (\fields ->+                    let matching = Lists.find (\f -> Equality.equal (Core.fieldName f) (Core.projectionFieldName proj)) fields+                    in (Optionals.cases matching (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                      Errors.noMatchingFieldErrorFieldName = (Core.projectionFieldName proj)})))) (\mf -> Right (Core.fieldTerm mf))))+          applyCases =+                  \cs -> \reducedArg -> Eithers.bind (ExtractCore.injection (Core.caseStatementTypeName cs) graph reducedArg) (\field ->+                    let matching =+                            Lists.find (\f -> Equality.equal (Core.caseAlternativeName f) (Core.fieldName field)) (Core.caseStatementCases cs)+                    in (Optionals.cases matching (Optionals.cases (Core.caseStatementDefault cs) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                      Errors.noMatchingFieldErrorFieldName = (Core.fieldName field)})))) (\x -> Right x)) (\mf -> Right (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.caseAlternativeHandler mf),+                      Core.applicationArgument = (Core.fieldTerm field)})))))+          applyIfNullary =+                  \eager2 -> \original -> \args ->+                    let stripped = Strip.deannotateTerm original+                        forProjection =+                                \proj -> \args2 -> Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                  let arg = Pairs.first uc+                                      remainingArgs = Pairs.second uc+                                  in (Eithers.bind (reduceArg eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (Eithers.bind (applyProjection proj reducedArg) (reduce eager2)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))+                        forCases =+                                \cs -> \args2 -> Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                  let arg = Pairs.first uc+                                      remainingArgs = Pairs.second uc+                                  in (Eithers.bind (reduceArg eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (Eithers.bind (applyCases cs reducedArg) (reduce eager2)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))+                        forUnwrap =+                                \name -> \args2 -> Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                  let arg = Pairs.first uc+                                      remainingArgs = Pairs.second uc+                                  in (Eithers.bind (reduceArg eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (Eithers.bind (ExtractCore.wrap name graph reducedArg) (reduce eager2)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))+                        forLambda =+                                \l -> \args2 ->+                                  let param = Core.lambdaParameter l+                                      body = Core.lambdaBody l+                                  in (Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                    let arg = Pairs.first uc+                                        remainingArgs = Pairs.second uc+                                    in (Eithers.bind (reduce eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (reduce eager2 (Variables.replaceFreeTermVariable param reducedArg body)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs)))))+                        forPrimitive =+                                \prim -> \arity -> \args2 ->+                                  let argList = Lists.take arity args2+                                      remainingArgs = Lists.drop arity args2+                                  in (Eithers.bind (Eithers.mapList (reduceArg eager2) argList) (\reducedArgs ->+                                    let strippedArgs = Lists.map Strip.deannotateTerm reducedArgs+                                    in (Eithers.bind (Eithers.bimap mapErrorToString (\x -> x) (Graph.primitiveImplementation prim cx graph strippedArgs)) (\primResult -> Eithers.bind (reduce eager2 primResult) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs)))))+                    in case stripped of+                      Core.TermApplication v0 -> applyIfNullary eager2 (Core.applicationFunction v0) (Lists.cons (Core.applicationArgument v0) args)+                      Core.TermCases v0 -> Logic.ifElse (Lists.null args) (Right original) (forCases v0 args)+                      Core.TermProject v0 -> Logic.ifElse (Lists.null args) (Right original) (forProjection v0 args)+                      Core.TermUnwrap v0 -> Logic.ifElse (Lists.null args) (Right original) (forUnwrap v0 args)+                      Core.TermLambda v0 -> Logic.ifElse (Lists.null args) (Right original) (forLambda v0 args)+                      Core.TermVariable v0 ->+                        let mBinding = Lexical.lookupBinding graph v0+                        in (Optionals.cases mBinding (+                          let mPrim = Lexical.lookupPrimitive graph v0+                          in (Optionals.cases mPrim (Right (applyToArguments original args)) (\prim ->+                            let arity = Arity.primitiveArity prim+                            in (Logic.ifElse (Equality.gt arity (Lists.length args)) (Right (applyToArguments original args)) (forPrimitive prim arity args))))) (\binding -> applyIfNullary eager2 (Core.bindingTerm binding) args))+                      Core.TermLet v0 ->+                        let bindings = Core.letBindings v0+                            body = Core.letBody v0+                            letExpr =+                                    \b -> Core.TermLet (Core.Let {+                                      Core.letBindings = [+                                        b],+                                      Core.letBody = (Core.TermVariable (Core.bindingName b))})+                            expandBinding =+                                    \b -> Core.Binding {+                                      Core.bindingName = (Core.bindingName b),+                                      Core.bindingTerm = (Variables.replaceFreeTermVariable (Core.bindingName b) (letExpr b) (Core.bindingTerm b)),+                                      Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                            expandedBindings = Lists.map expandBinding bindings+                            substituteBinding = \term2 -> \b -> Variables.replaceFreeTermVariable (Core.bindingName b) (Core.bindingTerm b) term2+                            substituteAll = \bs -> \term2 -> Lists.foldl substituteBinding term2 bs+                            expandedBody = substituteAll expandedBindings body+                        in (Eithers.bind (reduce eager2 expandedBody) (\reducedBody -> applyIfNullary eager2 reducedBody args))+                      _ -> Right (applyToArguments original args)+          mapping =+                  \recurse -> \mid -> Eithers.bind (Logic.ifElse (doRecurse eager mid) (recurse mid) (Right mid)) (\inner -> applyIfNullary eager inner [])+      in (Rewriting.rewriteTermM mapping term)+-- | Whether a term is closed, i.e. represents a complete program+termIsClosed :: Core.Term -> Bool+termIsClosed term = Sets.null (Variables.freeVariablesInTerm term)+-- | Whether a term has been fully reduced to a value+termIsValue :: Core.Term -> Bool+termIsValue term =++      let forList = \els -> Lists.foldl (\b -> \t -> Logic.and b (termIsValue t)) True els+          checkField = \f -> termIsValue (Core.fieldTerm f)+          checkFields = \fields -> Lists.foldl (\b -> \f -> Logic.and b (checkField f)) True fields+          checkCaseAlternatives =+                  \alts -> Lists.foldl (\b -> \a -> Logic.and b (termIsValue (Core.caseAlternativeHandler a))) True alts+      in case (Strip.deannotateTerm term) of+        Core.TermApplication _ -> False+        Core.TermCases v0 -> Logic.and (checkCaseAlternatives (Core.caseStatementCases v0)) (Optionals.cases (Core.caseStatementDefault v0) True termIsValue)+        Core.TermEither v0 -> Eithers.either (\l -> termIsValue l) (\r -> termIsValue r) v0+        Core.TermLambda v0 -> termIsValue (Core.lambdaBody v0)+        Core.TermLiteral _ -> True+        Core.TermProject _ -> True+        Core.TermUnwrap _ -> True+        Core.TermList v0 -> forList v0+        Core.TermMap v0 -> Lists.foldl (\b -> \kv -> Logic.and b (Logic.and (termIsValue (Pairs.first kv)) (termIsValue (Pairs.second kv)))) True (Maps.toList v0)+        Core.TermOptional v0 -> Optionals.cases v0 True termIsValue+        Core.TermRecord v0 -> checkFields (Core.recordFields v0)+        Core.TermSet v0 -> forList (Sets.toList v0)+        Core.TermInject v0 -> checkField (Core.injectionField v0)+        Core.TermUnit -> True+        Core.TermVariable _ -> False+        _ -> False
+ src/main/haskell/Hydra/Reflect.hs view
@@ -0,0 +1,236 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Reflection functions for working with term, type, and literal type variants, as well as numeric precision.++module Hydra.Reflect where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Find the precision of a given floating-point type+floatTypePrecision :: Core.FloatType -> Util.Precision+floatTypePrecision x =+    case x of+      Core.FloatTypeFloat32 -> Util.PrecisionBits 32+      Core.FloatTypeFloat64 -> Util.PrecisionBits 64+-- | All floating-point types in a canonical order+floatTypes :: [Core.FloatType]+floatTypes =+    [+      Core.FloatTypeFloat32,+      Core.FloatTypeFloat64]+-- | Find the float type for a given floating-point value+floatValueType :: Core.FloatValue -> Core.FloatType+floatValueType x =+    case x of+      Core.FloatValueFloat32 _ -> Core.FloatTypeFloat32+      Core.FloatValueFloat64 _ -> Core.FloatTypeFloat64+-- | Find whether a given integer type is signed (true) or unsigned (false)+integerTypeIsSigned :: Core.IntegerType -> Bool+integerTypeIsSigned x =+    case x of+      Core.IntegerTypeBigint -> True+      Core.IntegerTypeInt8 -> True+      Core.IntegerTypeInt16 -> True+      Core.IntegerTypeInt32 -> True+      Core.IntegerTypeInt64 -> True+      Core.IntegerTypeUint8 -> False+      Core.IntegerTypeUint16 -> False+      Core.IntegerTypeUint32 -> False+      Core.IntegerTypeUint64 -> False+-- | Find the precision of a given integer type+integerTypePrecision :: Core.IntegerType -> Util.Precision+integerTypePrecision x =+    case x of+      Core.IntegerTypeBigint -> Util.PrecisionArbitrary+      Core.IntegerTypeInt8 -> Util.PrecisionBits 8+      Core.IntegerTypeInt16 -> Util.PrecisionBits 16+      Core.IntegerTypeInt32 -> Util.PrecisionBits 32+      Core.IntegerTypeInt64 -> Util.PrecisionBits 64+      Core.IntegerTypeUint8 -> Util.PrecisionBits 8+      Core.IntegerTypeUint16 -> Util.PrecisionBits 16+      Core.IntegerTypeUint32 -> Util.PrecisionBits 32+      Core.IntegerTypeUint64 -> Util.PrecisionBits 64+-- | All integer types, in a canonical order+integerTypes :: [Core.IntegerType]+integerTypes =+    [+      Core.IntegerTypeBigint,+      Core.IntegerTypeInt8,+      Core.IntegerTypeInt16,+      Core.IntegerTypeInt32,+      Core.IntegerTypeInt64,+      Core.IntegerTypeUint8,+      Core.IntegerTypeUint16,+      Core.IntegerTypeUint32,+      Core.IntegerTypeUint64]+-- | Find the integer type for a given integer value+integerValueType :: Core.IntegerValue -> Core.IntegerType+integerValueType x =+    case x of+      Core.IntegerValueBigint _ -> Core.IntegerTypeBigint+      Core.IntegerValueInt8 _ -> Core.IntegerTypeInt8+      Core.IntegerValueInt16 _ -> Core.IntegerTypeInt16+      Core.IntegerValueInt32 _ -> Core.IntegerTypeInt32+      Core.IntegerValueInt64 _ -> Core.IntegerTypeInt64+      Core.IntegerValueUint8 _ -> Core.IntegerTypeUint8+      Core.IntegerValueUint16 _ -> Core.IntegerTypeUint16+      Core.IntegerValueUint32 _ -> Core.IntegerTypeUint32+      Core.IntegerValueUint64 _ -> Core.IntegerTypeUint64+-- | Find the literal type for a given literal value+literalType :: Core.Literal -> Core.LiteralType+literalType x =+    case x of+      Core.LiteralBinary _ -> Core.LiteralTypeBinary+      Core.LiteralBoolean _ -> Core.LiteralTypeBoolean+      Core.LiteralDecimal _ -> Core.LiteralTypeDecimal+      Core.LiteralFloat v0 -> (\injected_ -> Core.LiteralTypeFloat injected_) (floatValueType v0)+      Core.LiteralInteger v0 -> (\injected_ -> Core.LiteralTypeInteger injected_) (integerValueType v0)+      Core.LiteralString _ -> Core.LiteralTypeString+-- | Find the literal type inject (constructor) for a given literal value+literalTypeVariant :: Core.LiteralType -> Variants.LiteralVariant+literalTypeVariant x =+    case x of+      Core.LiteralTypeBinary -> Variants.LiteralVariantBinary+      Core.LiteralTypeBoolean -> Variants.LiteralVariantBoolean+      Core.LiteralTypeDecimal -> Variants.LiteralVariantDecimal+      Core.LiteralTypeFloat _ -> Variants.LiteralVariantFloat+      Core.LiteralTypeInteger _ -> Variants.LiteralVariantInteger+      Core.LiteralTypeString -> Variants.LiteralVariantString+-- | All literal types, in a canonical order+literalTypes :: [Core.LiteralType]+literalTypes =+    Lists.concat [+      [+        Core.LiteralTypeBinary,+        Core.LiteralTypeBoolean,+        Core.LiteralTypeDecimal],+      (Lists.map (\x -> Core.LiteralTypeFloat x) floatTypes),+      (Lists.map (\x -> Core.LiteralTypeInteger x) integerTypes),+      [+        Core.LiteralTypeString]]+-- | Find the literal inject (constructor) for a given literal value+literalVariant :: Core.Literal -> Variants.LiteralVariant+literalVariant arg_ = literalTypeVariant (literalType arg_)+-- | All literal variants, in a canonical order+literalVariants :: [Variants.LiteralVariant]+literalVariants =+    [+      Variants.LiteralVariantBinary,+      Variants.LiteralVariantBoolean,+      Variants.LiteralVariantDecimal,+      Variants.LiteralVariantFloat,+      Variants.LiteralVariantInteger,+      Variants.LiteralVariantString]+-- | Find the term inject (constructor) for a given term+termVariant :: Core.Term -> Variants.TermVariant+termVariant x =+    case x of+      Core.TermAnnotated _ -> Variants.TermVariantAnnotated+      Core.TermApplication _ -> Variants.TermVariantApplication+      Core.TermCases _ -> Variants.TermVariantCases+      Core.TermEither _ -> Variants.TermVariantEither+      Core.TermLambda _ -> Variants.TermVariantLambda+      Core.TermLet _ -> Variants.TermVariantLet+      Core.TermList _ -> Variants.TermVariantList+      Core.TermLiteral _ -> Variants.TermVariantLiteral+      Core.TermMap _ -> Variants.TermVariantMap+      Core.TermOptional _ -> Variants.TermVariantOptional+      Core.TermPair _ -> Variants.TermVariantPair+      Core.TermProject _ -> Variants.TermVariantProject+      Core.TermRecord _ -> Variants.TermVariantRecord+      Core.TermSet _ -> Variants.TermVariantSet+      Core.TermTypeApplication _ -> Variants.TermVariantTypeApplication+      Core.TermTypeLambda _ -> Variants.TermVariantTypeLambda+      Core.TermInject _ -> Variants.TermVariantInject+      Core.TermUnit -> Variants.TermVariantUnit+      Core.TermUnwrap _ -> Variants.TermVariantUnwrap+      Core.TermVariable _ -> Variants.TermVariantVariable+      Core.TermWrap _ -> Variants.TermVariantWrap+-- | All term (expression) variants, in a canonical order+termVariants :: [Variants.TermVariant]+termVariants =+    [+      Variants.TermVariantAnnotated,+      Variants.TermVariantApplication,+      Variants.TermVariantCases,+      Variants.TermVariantEither,+      Variants.TermVariantLambda,+      Variants.TermVariantLet,+      Variants.TermVariantList,+      Variants.TermVariantLiteral,+      Variants.TermVariantMap,+      Variants.TermVariantOptional,+      Variants.TermVariantPair,+      Variants.TermVariantProject,+      Variants.TermVariantRecord,+      Variants.TermVariantSet,+      Variants.TermVariantTypeLambda,+      Variants.TermVariantTypeApplication,+      Variants.TermVariantInject,+      Variants.TermVariantUnit,+      Variants.TermVariantUnwrap,+      Variants.TermVariantVariable,+      Variants.TermVariantWrap]+-- | Find the type inject (constructor) for a given type+typeVariant :: Core.Type -> Variants.TypeVariant+typeVariant x =+    case x of+      Core.TypeAnnotated _ -> Variants.TypeVariantAnnotated+      Core.TypeApplication _ -> Variants.TypeVariantApplication+      Core.TypeEither _ -> Variants.TypeVariantEither+      Core.TypeFunction _ -> Variants.TypeVariantFunction+      Core.TypeForall _ -> Variants.TypeVariantForall+      Core.TypeList _ -> Variants.TypeVariantList+      Core.TypeLiteral _ -> Variants.TypeVariantLiteral+      Core.TypeMap _ -> Variants.TypeVariantMap+      Core.TypeOptional _ -> Variants.TypeVariantOptional+      Core.TypePair _ -> Variants.TypeVariantPair+      Core.TypeRecord _ -> Variants.TypeVariantRecord+      Core.TypeSet _ -> Variants.TypeVariantSet+      Core.TypeUnion _ -> Variants.TypeVariantUnion+      Core.TypeUnit -> Variants.TypeVariantUnit+      Core.TypeVariable _ -> Variants.TypeVariantVariable+      Core.TypeVoid -> Variants.TypeVariantVoid+      Core.TypeWrap _ -> Variants.TypeVariantWrap+-- | All type variants, in a canonical order+typeVariants :: [Variants.TypeVariant]+typeVariants =+    [+      Variants.TypeVariantAnnotated,+      Variants.TypeVariantApplication,+      Variants.TypeVariantEither,+      Variants.TypeVariantFunction,+      Variants.TypeVariantForall,+      Variants.TypeVariantList,+      Variants.TypeVariantLiteral,+      Variants.TypeVariantMap,+      Variants.TypeVariantWrap,+      Variants.TypeVariantOptional,+      Variants.TypeVariantPair,+      Variants.TypeVariantRecord,+      Variants.TypeVariantSet,+      Variants.TypeVariantUnion,+      Variants.TypeVariantUnit,+      Variants.TypeVariantVariable,+      Variants.TypeVariantVoid]
+ src/main/haskell/Hydra/Relational.hs view
@@ -0,0 +1,84 @@+-- Note: this is an automatically generated file. Do not edit.+-- | An interpretation of Codd's Relational Model, as described in 'A Relational Model of Data for Large Shared Data Banks' (1970). Types ('domains') and values are parameterized so as to allow for application-specific implementations. No special support is provided for 'nonsimple' domains; i.e. relations are assumed to be normalized.++module Hydra.Relational where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | A name for a domain which serves to identify the role played by that domain in the given relation; a 'role name' in Codd+newtype ColumnName =+  ColumnName {+    unColumnName :: String}+  deriving (Eq, Ord, Read, Show)+_ColumnName = Core.Name "hydra.relational.ColumnName"+-- | An abstract specification of the domain represented by a column in a relation; a role+data ColumnSchema t =+  ColumnSchema {+    -- | A unique name for the column+    columnSchemaName :: ColumnName,+    -- | The domain (type) of the column+    columnSchemaDomain :: t}+  deriving (Eq, Ord, Read, Show)+_ColumnSchema = Core.Name "hydra.relational.ColumnSchema"+_ColumnSchema_name = Core.Name "name"+_ColumnSchema_domain = Core.Name "domain"+-- | A mapping from certain columns of a source relation to primary key columns of a target relation+data ForeignKey =+  ForeignKey {+    -- | The name of the target relation+    foreignKeyForeignRelation :: RelationName,+    -- | The mapping of source column names to target column names. The target column names must together make up the primary key of the target relation.+    foreignKeyKeys :: (M.Map ColumnName ColumnName)}+  deriving (Eq, Ord, Read, Show)+_ForeignKey = Core.Name "hydra.relational.ForeignKey"+_ForeignKey_foreignRelation = Core.Name "foreignRelation"+_ForeignKey_keys = Core.Name "keys"+-- | A primary key of a relation, specified either as a single column, or as a list of columns+newtype PrimaryKey =+  PrimaryKey {+    unPrimaryKey :: [ColumnName]}+  deriving (Eq, Ord, Read, Show)+_PrimaryKey = Core.Name "hydra.relational.PrimaryKey"+-- | A set of distinct n-tuples; a table+newtype Relation v =+  Relation {+    unRelation :: [Row v]}+  deriving (Eq, Ord, Read, Show)+_Relation = Core.Name "hydra.relational.Relation"+-- | A unique relation (table) name+newtype RelationName =+  RelationName {+    unRelationName :: String}+  deriving (Eq, Ord, Read, Show)+_RelationName = Core.Name "hydra.relational.RelationName"+-- | An abstract relation; the name and columns of a relation without its actual data+data RelationSchema t =+  RelationSchema {+    -- | A unique name for the relation+    relationSchemaName :: RelationName,+    -- | A list of column specifications+    relationSchemaColumns :: [ColumnSchema t],+    -- | Any number of primary keys for the relation, each of which must be valid for this relation+    relationSchemaPrimaryKeys :: [PrimaryKey],+    -- | Any number of foreign keys, each of which must be valid for both this relation and the target relation+    relationSchemaForeignKeys :: [ForeignKey]}+  deriving (Eq, Ord, Read, Show)+_RelationSchema = Core.Name "hydra.relational.RelationSchema"+_RelationSchema_name = Core.Name "name"+_RelationSchema_columns = Core.Name "columns"+_RelationSchema_primaryKeys = Core.Name "primaryKeys"+_RelationSchema_foreignKeys = Core.Name "foreignKeys"+-- | A domain-unordered (string-indexed, rather than position-indexed) relation+newtype Relationship v =+  Relationship {+    unRelationship :: (S.Set (M.Map ColumnName v))}+  deriving (Eq, Ord, Read, Show)+_Relationship = Core.Name "hydra.relational.Relationship"+-- | An n-tuple which is an element of a given relation+newtype Row v =+  Row {+    unRow :: [v]}+  deriving (Eq, Ord, Read, Show)+_Row = Core.Name "hydra.relational.Row"
+ src/main/haskell/Hydra/Resolution.hs view
@@ -0,0 +1,219 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Type dereference, lookup, requirements, and instantiation++module Hydra.Resolution where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+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.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Strip as Strip+import qualified Hydra.Substitution as Substitution+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Dereference a type name to get the actual type (Either version)+dereferenceType :: t0 -> Graph.Graph -> Core.Name -> Either Errors.Error (Maybe Core.Type)+dereferenceType cx graph name =++      let mel = Lexical.lookupBinding graph name+      in (Optionals.cases mel (Right Nothing) (\el -> Eithers.map Optionals.pure (Eithers.bimap (\_e -> Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = "type",+        Errors.unexpectedShapeErrorActual = (Errors.unDecodingError _e)}))) (\_a -> _a) (DecodeCore.type_ graph (Core.bindingTerm el)))))+-- | Test whether a given System F type is polymorphic (i.e., a forall type)+fTypeIsPolymorphic :: Core.Type -> Bool+fTypeIsPolymorphic typ =+    case typ of+      Core.TypeAnnotated v0 -> fTypeIsPolymorphic (Core.annotatedTypeBody v0)+      Core.TypeForall _ -> True+      _ -> False+-- | Build a map from field name to field term, given a list of fields+fieldMap :: [Core.Field] -> M.Map Core.Name Core.Term+fieldMap fields =++      let toPair = \f -> (Core.fieldName f, (Core.fieldTerm f))+      in (Maps.fromList (Lists.map toPair fields))+-- | Build a map from field name to field type, given a list of field types+fieldTypeMap :: [Core.FieldType] -> M.Map Core.Name Core.Type+fieldTypeMap fields =++      let toPair = \f -> (Core.fieldTypeName f, (Core.fieldTypeType f))+      in (Maps.fromList (Lists.map toPair fields))+-- | Get field types from a record or union type (Either version)+fieldTypes :: t0 -> Graph.Graph -> Core.Type -> Either Errors.Error (M.Map Core.Name Core.Type)+fieldTypes cx graph t =++      let toMap = \fields -> Maps.fromList (Lists.map (\ft -> (Core.fieldTypeName ft, (Core.fieldTypeType ft))) fields)+      in case (Strip.deannotateType t) of+        Core.TypeForall v0 -> fieldTypes cx graph (Core.forallTypeBody v0)+        Core.TypeRecord v0 -> Right (toMap v0)+        Core.TypeUnion v0 -> Right (toMap v0)+        Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 (Graph.graphSchemaTypes graph)) (Eithers.bind (Lexical.requireBinding graph v0) (\el -> Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "type",+          Errors.unexpectedShapeErrorActual = (Errors.unDecodingError _e)}))) (\_a -> _a) (DecodeCore.type_ graph (Core.bindingTerm el))) (\decodedType -> fieldTypes cx graph decodedType))) (\ts -> fieldTypes cx graph (Core.typeSchemeBody ts))+        _ -> Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "record or union type",+          Errors.unexpectedShapeErrorActual = (ShowCore.type_ t)})))+-- | Find a field type by name in a list of field types+findFieldType :: t0 -> Core.Name -> [Core.FieldType] -> Either Errors.Error Core.Type+findFieldType cx fname fields =++      let matchingFields = Lists.filter (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) (Core.unName fname)) fields+          noMatch =+                  Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                    Errors.noMatchingFieldErrorFieldName = fname})))+      in (Logic.ifElse (Lists.null matchingFields) noMatch (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Optionals.cases (Lists.maybeHead matchingFields) noMatch (\ft -> Right (Core.fieldTypeType ft))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorMultipleFields (Errors.MultipleFieldsError {+        Errors.multipleFieldsErrorFieldName = fname}))))))+-- | Fully strip a type of forall quantifiers, normalizing bound variable names for alpha-equivalence comparison+fullyStripAndNormalizeType :: Core.Type -> Core.Type+fullyStripAndNormalizeType typ =++      let go =+              \depth -> \subst -> \t -> case (Strip.deannotateType t) of+                Core.TypeForall v0 ->+                  let oldVar = Core.forallTypeParameter v0+                      newVar = Core.Name (Strings.cat2 "_" (Literals.showInt32 depth))+                  in (go (Math.add depth 1) (Maps.insert oldVar newVar subst) (Core.forallTypeBody v0))+                _ -> (subst, t)+          result = go 0 Maps.empty typ+          subst = Pairs.first result+          body = Pairs.second result+      in (Variables.substituteTypeVariables subst body)+-- | Fully strip a type of forall quantifiers+fullyStripType :: Core.Type -> Core.Type+fullyStripType typ =+    case (Strip.deannotateType typ) of+      Core.TypeForall v0 -> fullyStripType (Core.forallTypeBody v0)+      _ -> typ+-- | Instantiate a type by replacing all forall-bound type variables with fresh variables, threading InferenceContext+instantiateType :: Typing.InferenceContext -> Core.Type -> (Core.Type, Typing.InferenceContext)+instantiateType cx typ =++      let result = instantiateTypeScheme cx (typeToTypeScheme typ)+      in (Scoping.typeSchemeToFType (Pairs.first result), (Pairs.second result))+-- | Instantiate a type scheme with fresh variables, threading InferenceContext+instantiateTypeScheme :: Typing.InferenceContext -> Core.TypeScheme -> (Core.TypeScheme, Typing.InferenceContext)+instantiateTypeScheme cx scheme =++      let oldVars = Core.typeSchemeVariables scheme+          result = Names.freshNames (Lists.length oldVars) cx+          newVars = Pairs.first result+          cx2 = Pairs.second result+          subst = Typing.TypeSubst (Maps.fromList (Lists.zip oldVars (Lists.map (\x -> Core.TypeVariable x) newVars)))+          nameSubst = Maps.fromList (Lists.zip oldVars newVars)+          renamedConstraints =+                  Optionals.map (\oldConstraints -> Maps.fromList (Lists.map (\kv -> (Optionals.fromOptional (Pairs.first kv) (Maps.lookup (Pairs.first kv) nameSubst), (Pairs.second kv))) (Maps.toList oldConstraints))) (Core.typeSchemeConstraints scheme)+      in (+        Core.TypeScheme {+          Core.typeSchemeVariables = newVars,+          Core.typeSchemeBody = (Substitution.substInType subst (Core.typeSchemeBody scheme)),+          Core.typeSchemeConstraints = renamedConstraints},+        cx2)+-- | Apply type arguments to a nominal type+nominalApplication :: Core.Name -> [Core.Type] -> Core.Type+nominalApplication tname args =+    Lists.foldl (\t -> \a -> Core.TypeApplication (Core.ApplicationType {+      Core.applicationTypeFunction = t,+      Core.applicationTypeArgument = a})) (Core.TypeVariable tname) args+-- | Require a name to resolve to a record type+requireRecordType :: t0 -> Graph.Graph -> Core.Name -> Either Errors.Error [Core.FieldType]+requireRecordType cx graph name =++      let toRecord =+              \t -> case t of+                Core.TypeRecord v0 -> Just v0+                _ -> Nothing+      in (requireRowType cx "record type" toRecord graph name)+-- | Require a name to resolve to a row type+requireRowType :: t0 -> String -> (Core.Type -> Maybe t1) -> Graph.Graph -> Core.Name -> Either Errors.Error t1+requireRowType cx label getter graph name =++      let rawType =+              \t -> case t of+                Core.TypeAnnotated v0 -> rawType (Core.annotatedTypeBody v0)+                Core.TypeForall v0 -> rawType (Core.forallTypeBody v0)+                _ -> t+      in (Eithers.bind (requireType cx graph name) (\t -> Optionals.cases (getter (rawType t)) (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Errors.unexpectedShapeErrorExpected = (Strings.cat2 label " type"),+        Errors.unexpectedShapeErrorActual = (Strings.cat2 (Core.unName name) (Strings.cat2 ": " (ShowCore.type_ t)))})))) (\x -> Right x)))+-- | Look up a schema type and instantiate it, threading InferenceContext+requireSchemaType :: Typing.InferenceContext -> M.Map Core.Name Core.TypeScheme -> Core.Name -> Either Errors.Error (Core.TypeScheme, Typing.InferenceContext)+requireSchemaType cx types tname =+    Optionals.cases (Maps.lookup tname types) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+      Errors.noSuchBindingErrorName = tname})))) (\ts -> Right (instantiateTypeScheme cx (Strip.deannotateTypeSchemeRecursive ts)))+-- | Require a type by name+requireType :: t0 -> Graph.Graph -> Core.Name -> Either Errors.Error Core.Type+requireType cx graph name =+    Optionals.cases (Maps.lookup name (Graph.graphSchemaTypes graph)) (Optionals.cases (Maps.lookup name (Graph.graphBoundTypes graph)) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+      Errors.noSuchBindingErrorName = name})))) (\ts -> Right (Scoping.typeSchemeToFType ts))) (\ts -> Right (Scoping.typeSchemeToFType ts))+-- | Require a field type from a union type+requireUnionField :: t0 -> Graph.Graph -> Core.Name -> Core.Name -> Either Errors.Error Core.Type+requireUnionField cx graph tname fname =++      let withRowType =+              \rt ->+                let noMatchErr =+                        Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                          Errors.noMatchingFieldErrorFieldName = fname})))+                in (Optionals.cases (Lists.find (\ft -> Equality.equal (Core.fieldTypeName ft) fname) rt) noMatchErr (\ft -> Right (Core.fieldTypeType ft)))+      in (Eithers.bind (requireUnionType cx graph tname) withRowType)+-- | Require a name to resolve to a union type+requireUnionType :: t0 -> Graph.Graph -> Core.Name -> Either Errors.Error [Core.FieldType]+requireUnionType cx graph name =++      let toUnion =+              \t -> case t of+                Core.TypeUnion v0 -> Just v0+                _ -> Nothing+      in (requireRowType cx "union" toUnion graph name)+-- | Resolve a type, dereferencing type variables+resolveType :: Graph.Graph -> Core.Type -> Maybe Core.Type+resolveType graph typ =+    case (Strip.deannotateType typ) of+      Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 (Graph.graphSchemaTypes graph)) (Optionals.map (\ts -> Scoping.typeSchemeToFType ts) (Maps.lookup v0 (Graph.graphBoundTypes graph))) (\ts -> Just (Scoping.typeSchemeToFType ts))+      _ -> Just typ+-- | Convert a (System F -style) type to a type scheme+typeToTypeScheme :: Core.Type -> Core.TypeScheme+typeToTypeScheme t0 =++      let helper =+              \vars -> \t -> case (Strip.deannotateType t) of+                Core.TypeForall v0 -> helper (Lists.cons (Core.forallTypeParameter v0) vars) (Core.forallTypeBody v0)+                _ -> Core.TypeScheme {+                  Core.typeSchemeVariables = (Lists.reverse vars),+                  Core.typeSchemeBody = t,+                  Core.typeSchemeConstraints = Nothing}+      in (helper [] t0)
+ src/main/haskell/Hydra/Rewriting.hs view
@@ -0,0 +1,968 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Core rewrite and fold combinators for terms and types++module Hydra.Rewriting where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Lists as Lists+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.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Scoping as Scoping+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Apply a term-level function inside any leading type lambdas+applyInsideTypeLambdasAndAnnotations :: (Core.Term -> Core.Term) -> Core.Term -> Core.Term+applyInsideTypeLambdasAndAnnotations f term0 =+    case term0 of+      Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {+        Core.annotatedTermBody = (applyInsideTypeLambdasAndAnnotations f (Core.annotatedTermBody v0)),+        Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})+      Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda {+        Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+        Core.typeLambdaBody = (applyInsideTypeLambdasAndAnnotations f (Core.typeLambdaBody v0))})+      _ -> f term0+-- | Fold over a term, traversing its subterms in the specified order+foldOverTerm :: Coders.TraversalOrder -> (t0 -> Core.Term -> t0) -> t0 -> Core.Term -> t0+foldOverTerm order fld b0 term =+    case order of+      Coders.TraversalOrderPre -> Lists.foldl (foldOverTerm order fld) (fld b0 term) (subterms term)+      Coders.TraversalOrderPost -> fld (Lists.foldl (foldOverTerm order fld) b0 (subterms term)) term+-- | Fold over a type, traversing its subtypes in the specified order+foldOverType :: Coders.TraversalOrder -> (t0 -> Core.Type -> t0) -> t0 -> Core.Type -> t0+foldOverType order fld b0 typ =+    case order of+      Coders.TraversalOrderPre -> Lists.foldl (foldOverType order fld) (fld b0 typ) (subtypes typ)+      Coders.TraversalOrderPost -> fld (Lists.foldl (foldOverType order fld) b0 (subtypes typ)) typ+-- | Fold over a term to produce a value, with both Graph and accessor path tracked. Like rewriteAndFoldTermWithGraphAndPath, but only folds without rewriting. The Graph is automatically updated when descending into lambdas, lets, and type lambdas.+foldTermWithGraphAndPath :: ((t0 -> Core.Term -> t0) -> [Paths.SubtermStep] -> Graph.Graph -> t0 -> Core.Term -> t0) -> Graph.Graph -> t0 -> Core.Term -> t0+foldTermWithGraphAndPath f cx0 val0 term0 =++      let wrapper =+              \recurse -> \path -> \cx -> \val -> \term ->+                let recurseForUser =+                        \valIn -> \subterm ->+                          let r = recurse valIn subterm+                          in (Pairs.first r)+                in (f recurseForUser path cx val term, term)+          result = rewriteAndFoldTermWithGraphAndPath wrapper cx0 val0 term0+      in (Pairs.first result)+-- | Apply a transformation to the first type beneath a chain of annotations+mapBeneathTypeAnnotations :: (Core.Type -> Core.Type) -> Core.Type -> Core.Type+mapBeneathTypeAnnotations f t =+    case t of+      Core.TypeAnnotated v0 -> Core.TypeAnnotated (Core.AnnotatedType {+        Core.annotatedTypeBody = (mapBeneathTypeAnnotations f (Core.annotatedTypeBody v0)),+        Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)})+      _ -> f t+-- | Rewrite a term, and at the same time, fold a function over it, accumulating a value+rewriteAndFoldTerm :: ((t0 -> Core.Term -> (t0, Core.Term)) -> t0 -> Core.Term -> (t0, Core.Term)) -> t0 -> Core.Term -> (t0, Core.Term)+rewriteAndFoldTerm f term0 =++      let fsub =+              \recurse -> \val0 -> \term02 ->+                let forSingle =+                        \rec -> \cons -> \val -> \term ->+                          let r = rec val term+                          in (Pairs.first r, (cons (Pairs.second r)))+                    forMany =+                            \rec -> \cons -> \val -> \els ->+                              let rr =+                                      Lists.foldl (\r -> \el ->+                                        let r2 = rec (Pairs.first r) el+                                        in (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second r)))) (val, []) els+                              in (Pairs.first rr, (cons (Lists.reverse (Pairs.second rr))))+                    forField =+                            \val -> \field ->+                              let r = recurse val (Core.fieldTerm field)+                              in (+                                Pairs.first r,+                                Core.Field {+                                  Core.fieldName = (Core.fieldName field),+                                  Core.fieldTerm = (Pairs.second r)})+                    forFields = forMany forField (\x -> x)+                    forCaseAlternative =+                            \val -> \alt ->+                              let r = recurse val (Core.caseAlternativeHandler alt)+                              in (+                                Pairs.first r,+                                Core.CaseAlternative {+                                  Core.caseAlternativeName = (Core.caseAlternativeName alt),+                                  Core.caseAlternativeHandler = (Pairs.second r)})+                    forCaseAlternatives = forMany forCaseAlternative (\x -> x)+                    forPair =+                            \val -> \kv ->+                              let rk = recurse val (Pairs.first kv)+                                  rv = recurse (Pairs.first rk) (Pairs.second kv)+                              in (Pairs.first rv, (Pairs.second rk, (Pairs.second rv)))+                    forBinding =+                            \val -> \binding ->+                              let r = recurse val (Core.bindingTerm binding)+                              in (+                                Pairs.first r,+                                Core.Binding {+                                  Core.bindingName = (Core.bindingName binding),+                                  Core.bindingTerm = (Pairs.second r),+                                  Core.bindingTypeScheme = (Core.bindingTypeScheme binding)})+                    dflt = (val0, term02)+                in case term02 of+                  Core.TermAnnotated v0 -> forSingle recurse (\t -> Core.TermAnnotated (Core.AnnotatedTerm {+                    Core.annotatedTermBody = t,+                    Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})) val0 (Core.annotatedTermBody v0)+                  Core.TermApplication v0 ->+                    let rlhs = recurse val0 (Core.applicationFunction v0)+                        rrhs = recurse (Pairs.first rlhs) (Core.applicationArgument v0)+                    in (+                      Pairs.first rrhs,+                      (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Pairs.second rlhs),+                        Core.applicationArgument = (Pairs.second rrhs)})))+                  Core.TermCases v0 ->+                    let rmd = Optionals.map (recurse val0) (Core.caseStatementDefault v0)+                        val1 = Optionals.cases rmd val0 Pairs.first+                        rcases = forCaseAlternatives val1 (Core.caseStatementCases v0)+                    in (+                      Pairs.first rcases,+                      (Core.TermCases (Core.CaseStatement {+                        Core.caseStatementTypeName = (Core.caseStatementTypeName v0),+                        Core.caseStatementDefault = (Optionals.map Pairs.second rmd),+                        Core.caseStatementCases = (Pairs.second rcases)})))+                  Core.TermEither v0 -> Eithers.either (\l ->+                    let rl = recurse val0 l+                    in (Pairs.first rl, (Core.TermEither (Left (Pairs.second rl))))) (\r ->+                    let rr = recurse val0 r+                    in (Pairs.first rr, (Core.TermEither (Right (Pairs.second rr))))) v0+                  Core.TermLambda v0 ->+                    let rl = recurse val0 (Core.lambdaBody v0)+                    in (+                      Pairs.first rl,+                      (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.lambdaParameter v0),+                        Core.lambdaDomain = (Core.lambdaDomain v0),+                        Core.lambdaBody = (Pairs.second rl)})))+                  Core.TermLet v0 ->+                    let renv = recurse val0 (Core.letBody v0)+                    in (forMany forBinding (\bins -> Core.TermLet (Core.Let {+                      Core.letBindings = bins,+                      Core.letBody = (Pairs.second renv)})) (Pairs.first renv) (Core.letBindings v0))+                  Core.TermList v0 -> forMany recurse (\x -> Core.TermList x) val0 v0+                  Core.TermMap v0 -> forMany forPair (\pairs -> Core.TermMap (Maps.fromList pairs)) val0 (Maps.toList v0)+                  Core.TermOptional v0 -> Optionals.cases v0 dflt (\t -> forSingle recurse (\t1 -> Core.TermOptional (Just t1)) val0 t)+                  Core.TermPair v0 ->+                    let rf = recurse val0 (Pairs.first v0)+                        rs = recurse (Pairs.first rf) (Pairs.second v0)+                    in (Pairs.first rs, (Core.TermPair (Pairs.second rf, (Pairs.second rs))))+                  Core.TermProject v0 -> (val0, (Core.TermProject v0))+                  Core.TermRecord v0 -> forMany forField (\fields -> Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.recordTypeName v0),+                    Core.recordFields = fields})) val0 (Core.recordFields v0)+                  Core.TermSet v0 -> forMany recurse (\e -> Core.TermSet (Sets.fromList e)) val0 (Sets.toList v0)+                  Core.TermTypeApplication v0 -> forSingle recurse (\t -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = t,+                    Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})) val0 (Core.typeApplicationTermBody v0)+                  Core.TermTypeLambda v0 -> forSingle recurse (\t -> Core.TermTypeLambda (Core.TypeLambda {+                    Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+                    Core.typeLambdaBody = t})) val0 (Core.typeLambdaBody v0)+                  Core.TermInject v0 -> forSingle recurse (\t -> Core.TermInject (Core.Injection {+                    Core.injectionTypeName = (Core.injectionTypeName v0),+                    Core.injectionField = Core.Field {+                      Core.fieldName = (Core.fieldName (Core.injectionField v0)),+                      Core.fieldTerm = t}})) val0 (Core.fieldTerm (Core.injectionField v0))+                  Core.TermUnwrap v0 -> (val0, (Core.TermUnwrap v0))+                  Core.TermWrap v0 -> forSingle recurse (\t -> Core.TermWrap (Core.WrappedTerm {+                    Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0),+                    Core.wrappedTermBody = t})) val0 (Core.wrappedTermBody v0)+                  _ -> dflt+          recurse = f (fsub recurse)+      in (recurse term0)+-- | Rewrite a term while folding to produce a value, with Graph updated as we descend into subterms. Combines the features of rewriteAndFoldTerm and rewriteTermWithGraph. The user function f receives a recurse function that handles subterm traversal and Graph management.+rewriteAndFoldTermWithGraph :: ((t0 -> Core.Term -> (t0, Core.Term)) -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)) -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)+rewriteAndFoldTermWithGraph f cx0 val0 term0 =++      let wrapper =+              \lowLevelRecurse -> \valAndCx -> \term ->+                let val = Pairs.first valAndCx+                    cx = Pairs.second valAndCx+                    cx1 =+                            case term of+                              Core.TermLambda v0 -> Scoping.extendGraphForLambda cx v0+                              Core.TermLet v0 -> Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) cx v0+                              Core.TermTypeLambda v0 -> Scoping.extendGraphForTypeLambda cx v0+                              _ -> cx+                    recurseForUser =+                            \newVal -> \subterm ->+                              let result = lowLevelRecurse (newVal, cx1) subterm+                              in (Pairs.first (Pairs.first result), (Pairs.second result))+                    fResult = f recurseForUser cx1 val term+                in ((Pairs.first fResult, cx), (Pairs.second fResult))+          result = rewriteAndFoldTerm wrapper (val0, cx0) term0+      in (Pairs.first (Pairs.first result), (Pairs.second result))+-- | Rewrite a term while folding to produce a value, with both Graph and accessor path tracked. The path is a list of SubtermSteps representing the position from the root to the current term. Combines the features of rewriteAndFoldTermWithPath and Graph tracking. The Graph is automatically updated when descending into lambdas, lets, and type lambdas.+rewriteAndFoldTermWithGraphAndPath :: ((t0 -> Core.Term -> (t0, Core.Term)) -> [Paths.SubtermStep] -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)) -> Graph.Graph -> t0 -> Core.Term -> (t0, Core.Term)+rewriteAndFoldTermWithGraphAndPath f cx0 val0 term0 =++      let wrapper =+              \recurse -> \path -> \cxAndVal -> \term ->+                let cx = Pairs.first cxAndVal+                    val = Pairs.second cxAndVal+                    cx1 =+                            case term of+                              Core.TermLambda v0 -> Scoping.extendGraphForLambda cx v0+                              Core.TermLet v0 -> Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) cx v0+                              Core.TermTypeLambda v0 -> Scoping.extendGraphForTypeLambda cx v0+                              _ -> cx+                    recurseForUser =+                            \valIn -> \termIn ->+                              let result = recurse path (cx1, valIn) termIn+                              in (Pairs.second (Pairs.first result), (Pairs.second result))+                    fResult = f recurseForUser path cx1 val term+                in ((cx, (Pairs.first fResult)), (Pairs.second fResult))+          result = rewriteAndFoldTermWithPath wrapper (cx0, val0) term0+      in (Pairs.second (Pairs.first result), (Pairs.second result))+-- | Rewrite a term with path tracking, and fold a function over it, accumulating a value. The path is a list of SubtermSteps from root to current position.+rewriteAndFoldTermWithPath :: (([Paths.SubtermStep] -> t0 -> Core.Term -> (t0, Core.Term)) -> [Paths.SubtermStep] -> t0 -> Core.Term -> (t0, Core.Term)) -> t0 -> Core.Term -> (t0, Core.Term)+rewriteAndFoldTermWithPath f term0 =++      let fsub =+              \recurse -> \path -> \val0 -> \term02 ->+                let forSingleWithAccessor =+                        \rec -> \cons -> \accessor -> \val -> \term ->+                          let r = rec (Lists.concat2 path [+                                accessor]) val term+                          in (Pairs.first r, (cons (Pairs.second r)))+                    forManyWithAccessors =+                            \rec -> \cons -> \val -> \accessorTermPairs ->+                              let rr =+                                      Lists.foldl (\r -> \atp ->+                                        let r2 = rec (Lists.concat2 path [+                                              Pairs.first atp]) (Pairs.first r) (Pairs.second atp)+                                        in (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second r)))) (val, []) accessorTermPairs+                              in (Pairs.first rr, (cons (Lists.reverse (Pairs.second rr))))+                    forFieldWithAccessor =+                            \mkAccessor -> \val -> \field ->+                              let r = recurse (Lists.concat2 path [+                                    mkAccessor (Core.fieldName field)]) val (Core.fieldTerm field)+                              in (+                                Pairs.first r,+                                Core.Field {+                                  Core.fieldName = (Core.fieldName field),+                                  Core.fieldTerm = (Pairs.second r)})+                    forFieldsWithAccessor =+                            \mkAccessor -> forManyWithAccessors (\path1 -> \val1 -> \field1 -> forFieldWithAccessor mkAccessor val1 field1) (\x -> x)+                    forPairWithAccessors =+                            \keyAccessor -> \valAccessor -> \val -> \kv ->+                              let rk = recurse (Lists.concat2 path [+                                    keyAccessor]) val (Pairs.first kv)+                                  rv = recurse (Lists.concat2 path [+                                        valAccessor]) (Pairs.first rk) (Pairs.second kv)+                              in (Pairs.first rv, (Pairs.second rk, (Pairs.second rv)))+                    forBindingWithAccessor =+                            \val -> \binding ->+                              let r = recurse (Lists.concat2 path [+                                    Paths.SubtermStepLetBinding (Core.bindingName binding)]) val (Core.bindingTerm binding)+                              in (+                                Pairs.first r,+                                Core.Binding {+                                  Core.bindingName = (Core.bindingName binding),+                                  Core.bindingTerm = (Pairs.second r),+                                  Core.bindingTypeScheme = (Core.bindingTypeScheme binding)})+                    dflt = (val0, term02)+                in case term02 of+                  Core.TermAnnotated v0 -> forSingleWithAccessor recurse (\t -> Core.TermAnnotated (Core.AnnotatedTerm {+                    Core.annotatedTermBody = t,+                    Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})) Paths.SubtermStepAnnotatedBody val0 (Core.annotatedTermBody v0)+                  Core.TermApplication v0 ->+                    let rlhs = recurse (Lists.concat2 path [+                          Paths.SubtermStepApplicationFunction]) val0 (Core.applicationFunction v0)+                        rrhs = recurse (Lists.concat2 path [+                              Paths.SubtermStepApplicationArgument]) (Pairs.first rlhs) (Core.applicationArgument v0)+                    in (+                      Pairs.first rrhs,+                      (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Pairs.second rlhs),+                        Core.applicationArgument = (Pairs.second rrhs)})))+                  Core.TermCases v0 ->+                    let rmd =+                            Optionals.map (\def -> recurse (Lists.concat2 path [+                              Paths.SubtermStepUnionCasesDefault]) val0 def) (Core.caseStatementDefault v0)+                        val1 = Optionals.cases rmd val0 Pairs.first+                        rcases =+                                forManyWithAccessors recurse (\x -> x) val1 (Lists.map (\f2 -> (Paths.SubtermStepUnionCasesBranch (Core.caseAlternativeName f2), (Core.caseAlternativeHandler f2))) (Core.caseStatementCases v0))+                    in (+                      Pairs.first rcases,+                      (Core.TermCases (Core.CaseStatement {+                        Core.caseStatementTypeName = (Core.caseStatementTypeName v0),+                        Core.caseStatementDefault = (Optionals.map Pairs.second rmd),+                        Core.caseStatementCases = (Lists.map (\ft -> Core.CaseAlternative {+                          Core.caseAlternativeName = (Pairs.first ft),+                          Core.caseAlternativeHandler = (Pairs.second ft)}) (Lists.zip (Lists.map Core.caseAlternativeName (Core.caseStatementCases v0)) (Pairs.second rcases)))})))+                  Core.TermEither v0 -> Eithers.either (\l ->+                    let rl = recurse (Lists.concat2 path [+                          Paths.SubtermStepSumTerm]) val0 l+                    in (Pairs.first rl, (Core.TermEither (Left (Pairs.second rl))))) (\r ->+                    let rr = recurse (Lists.concat2 path [+                          Paths.SubtermStepSumTerm]) val0 r+                    in (Pairs.first rr, (Core.TermEither (Right (Pairs.second rr))))) v0+                  Core.TermLambda v0 ->+                    let rl = recurse (Lists.concat2 path [+                          Paths.SubtermStepLambdaBody]) val0 (Core.lambdaBody v0)+                    in (+                      Pairs.first rl,+                      (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.lambdaParameter v0),+                        Core.lambdaDomain = (Core.lambdaDomain v0),+                        Core.lambdaBody = (Pairs.second rl)})))+                  Core.TermLet v0 ->+                    let renv = recurse (Lists.concat2 path [+                          Paths.SubtermStepLetBody]) val0 (Core.letBody v0)+                        rbindings =+                                Lists.foldl (\r -> \binding ->+                                  let rb = forBindingWithAccessor (Pairs.first r) binding+                                  in (Pairs.first rb, (Lists.cons (Pairs.second rb) (Pairs.second r)))) (Pairs.first renv, []) (Core.letBindings v0)+                    in (+                      Pairs.first rbindings,+                      (Core.TermLet (Core.Let {+                        Core.letBindings = (Lists.reverse (Pairs.second rbindings)),+                        Core.letBody = (Pairs.second renv)})))+                  Core.TermList v0 ->+                    let idx = 0+                        rr =+                                Lists.foldl (\r -> \el ->+                                  let r2 = recurse (Lists.concat2 path [+                                        Paths.SubtermStepListElement (Pairs.first r)]) (Pairs.first (Pairs.second r)) el+                                  in (Math.add (Pairs.first r) 1, (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second (Pairs.second r)))))) (idx, (val0, [])) v0+                    in (Pairs.first (Pairs.second rr), (Core.TermList (Lists.reverse (Pairs.second (Pairs.second rr)))))+                  Core.TermMap v0 ->+                    let idx = 0+                        rr =+                                Lists.foldl (\r -> \kv ->+                                  let rk = recurse (Lists.concat2 path [+                                        Paths.SubtermStepMapKey (Pairs.first r)]) (Pairs.first (Pairs.second r)) (Pairs.first kv)+                                      rv = recurse (Lists.concat2 path [+                                            Paths.SubtermStepMapValue (Pairs.first r)]) (Pairs.first rk) (Pairs.second kv)+                                  in (Math.add (Pairs.first r) 1, (Pairs.first rv, (Lists.cons (Pairs.second rk, (Pairs.second rv)) (Pairs.second (Pairs.second r)))))) (idx, (val0, [])) (Maps.toList v0)+                    in (Pairs.first (Pairs.second rr), (Core.TermMap (Maps.fromList (Lists.reverse (Pairs.second (Pairs.second rr))))))+                  Core.TermOptional v0 -> Optionals.cases v0 dflt (\t -> forSingleWithAccessor recurse (\t1 -> Core.TermOptional (Just t1)) Paths.SubtermStepOptionalTerm val0 t)+                  Core.TermPair v0 ->+                    let rf = recurse (Lists.concat2 path [+                          Paths.SubtermStepProductTerm 0]) val0 (Pairs.first v0)+                        rs = recurse (Lists.concat2 path [+                              Paths.SubtermStepProductTerm 1]) (Pairs.first rf) (Pairs.second v0)+                    in (Pairs.first rs, (Core.TermPair (Pairs.second rf, (Pairs.second rs))))+                  Core.TermProject v0 -> (val0, (Core.TermProject v0))+                  Core.TermRecord v0 ->+                    let rfields =+                            forManyWithAccessors recurse (\x -> x) val0 (Lists.map (\f2 -> (Paths.SubtermStepRecordField (Core.fieldName f2), (Core.fieldTerm f2))) (Core.recordFields v0))+                    in (+                      Pairs.first rfields,+                      (Core.TermRecord (Core.Record {+                        Core.recordTypeName = (Core.recordTypeName v0),+                        Core.recordFields = (Lists.map (\ft -> Core.Field {+                          Core.fieldName = (Pairs.first ft),+                          Core.fieldTerm = (Pairs.second ft)}) (Lists.zip (Lists.map Core.fieldName (Core.recordFields v0)) (Pairs.second rfields)))})))+                  Core.TermSet v0 ->+                    let idx = 0+                        rr =+                                Lists.foldl (\r -> \el ->+                                  let r2 = recurse (Lists.concat2 path [+                                        Paths.SubtermStepSetElement (Pairs.first r)]) (Pairs.first (Pairs.second r)) el+                                  in (Math.add (Pairs.first r) 1, (Pairs.first r2, (Lists.cons (Pairs.second r2) (Pairs.second (Pairs.second r)))))) (idx, (val0, [])) (Sets.toList v0)+                    in (Pairs.first (Pairs.second rr), (Core.TermSet (Sets.fromList (Lists.reverse (Pairs.second (Pairs.second rr))))))+                  Core.TermTypeApplication v0 -> forSingleWithAccessor recurse (\t -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = t,+                    Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})) Paths.SubtermStepTypeApplicationTerm val0 (Core.typeApplicationTermBody v0)+                  Core.TermTypeLambda v0 -> forSingleWithAccessor recurse (\t -> Core.TermTypeLambda (Core.TypeLambda {+                    Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+                    Core.typeLambdaBody = t})) Paths.SubtermStepTypeLambdaBody val0 (Core.typeLambdaBody v0)+                  Core.TermInject v0 -> forSingleWithAccessor recurse (\t -> Core.TermInject (Core.Injection {+                    Core.injectionTypeName = (Core.injectionTypeName v0),+                    Core.injectionField = Core.Field {+                      Core.fieldName = (Core.fieldName (Core.injectionField v0)),+                      Core.fieldTerm = t}})) Paths.SubtermStepInjectionTerm val0 (Core.fieldTerm (Core.injectionField v0))+                  Core.TermUnwrap v0 -> (val0, (Core.TermUnwrap v0))+                  Core.TermWrap v0 -> forSingleWithAccessor recurse (\t -> Core.TermWrap (Core.WrappedTerm {+                    Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0),+                    Core.wrappedTermBody = t})) Paths.SubtermStepWrappedTerm val0 (Core.wrappedTermBody v0)+                  _ -> dflt+          recurse = f (fsub recurse)+      in (recurse [] term0)+-- | Rewrite a term with a custom transformation function. The function receives a recursive walker and the current term and decides whether to recurse, replace, or both.+rewriteTerm :: ((Core.Term -> Core.Term) -> Core.Term -> Core.Term) -> Core.Term -> Core.Term+rewriteTerm f term0 =++      let fsub =+              \recurse -> \term ->+                let forField =+                        \f2 -> Core.Field {+                          Core.fieldName = (Core.fieldName f2),+                          Core.fieldTerm = (recurse (Core.fieldTerm f2))}+                    forCaseAlternative =+                            \a -> Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.caseAlternativeName a),+                              Core.caseAlternativeHandler = (recurse (Core.caseAlternativeHandler a))}+                    forLet =+                            \lt ->+                              let mapBinding =+                                      \b -> Core.Binding {+                                        Core.bindingName = (Core.bindingName b),+                                        Core.bindingTerm = (recurse (Core.bindingTerm b)),+                                        Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                              in Core.Let {+                                Core.letBindings = (Lists.map mapBinding (Core.letBindings lt)),+                                Core.letBody = (recurse (Core.letBody lt))}+                    forMap =+                            \m ->+                              let forPair = \p -> (recurse (Pairs.first p), (recurse (Pairs.second p)))+                              in (Maps.fromList (Lists.map forPair (Maps.toList m)))+                in case term of+                  Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {+                    Core.annotatedTermBody = (recurse (Core.annotatedTermBody v0)),+                    Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})+                  Core.TermApplication v0 -> Core.TermApplication (Core.Application {+                    Core.applicationFunction = (recurse (Core.applicationFunction v0)),+                    Core.applicationArgument = (recurse (Core.applicationArgument v0))})+                  Core.TermCases v0 -> Core.TermCases (Core.CaseStatement {+                    Core.caseStatementTypeName = (Core.caseStatementTypeName v0),+                    Core.caseStatementDefault = (Optionals.map recurse (Core.caseStatementDefault v0)),+                    Core.caseStatementCases = (Lists.map forCaseAlternative (Core.caseStatementCases v0))})+                  Core.TermEither v0 -> Core.TermEither (Eithers.either (\l -> Left (recurse l)) (\r -> Right (recurse r)) v0)+                  Core.TermLambda v0 -> Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.lambdaParameter v0),+                    Core.lambdaDomain = (Core.lambdaDomain v0),+                    Core.lambdaBody = (recurse (Core.lambdaBody v0))})+                  Core.TermLet v0 -> Core.TermLet (forLet v0)+                  Core.TermList v0 -> Core.TermList (Lists.map recurse v0)+                  Core.TermLiteral v0 -> Core.TermLiteral v0+                  Core.TermMap v0 -> Core.TermMap (forMap v0)+                  Core.TermOptional v0 -> Core.TermOptional (Optionals.map recurse v0)+                  Core.TermPair v0 -> Core.TermPair (recurse (Pairs.first v0), (recurse (Pairs.second v0)))+                  Core.TermProject v0 -> Core.TermProject v0+                  Core.TermRecord v0 -> Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.recordTypeName v0),+                    Core.recordFields = (Lists.map forField (Core.recordFields v0))})+                  Core.TermSet v0 -> Core.TermSet (Sets.fromList (Lists.map recurse (Sets.toList v0)))+                  Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = (recurse (Core.typeApplicationTermBody v0)),+                    Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})+                  Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda {+                    Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+                    Core.typeLambdaBody = (recurse (Core.typeLambdaBody v0))})+                  Core.TermInject v0 -> Core.TermInject (Core.Injection {+                    Core.injectionTypeName = (Core.injectionTypeName v0),+                    Core.injectionField = (forField (Core.injectionField v0))})+                  Core.TermUnit -> Core.TermUnit+                  Core.TermUnwrap v0 -> Core.TermUnwrap v0+                  Core.TermVariable v0 -> Core.TermVariable v0+                  Core.TermWrap v0 -> Core.TermWrap (Core.WrappedTerm {+                    Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0),+                    Core.wrappedTermBody = (recurse (Core.wrappedTermBody v0))})+          recurse = f (fsub recurse)+      in (recurse term0)+-- | Either-based term rewriting with custom transformation function+rewriteTermM :: ((Core.Term -> Either t0 Core.Term) -> Core.Term -> Either t0 Core.Term) -> Core.Term -> Either t0 Core.Term+rewriteTermM f term0 =++      let fsub =+              \recurse -> \term ->+                let forField =+                        \field -> Eithers.bind (recurse (Core.fieldTerm field)) (\t -> Right (Core.Field {+                          Core.fieldName = (Core.fieldName field),+                          Core.fieldTerm = t}))+                    forCaseAlternative =+                            \alt -> Eithers.bind (recurse (Core.caseAlternativeHandler alt)) (\t -> Right (Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.caseAlternativeName alt),+                              Core.caseAlternativeHandler = t}))+                    forPair =+                            \kv -> Eithers.bind (recurse (Pairs.first kv)) (\k -> Eithers.bind (recurse (Pairs.second kv)) (\v -> Right (k, v)))+                    mapBinding =+                            \b -> Eithers.bind (recurse (Core.bindingTerm b)) (\v -> Right (Core.Binding {+                              Core.bindingName = (Core.bindingName b),+                              Core.bindingTerm = v,+                              Core.bindingTypeScheme = (Core.bindingTypeScheme b)}))+                in case term of+                  Core.TermAnnotated v0 -> Eithers.bind (recurse (Core.annotatedTermBody v0)) (\ex -> Right (Core.TermAnnotated (Core.AnnotatedTerm {+                    Core.annotatedTermBody = ex,+                    Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})))+                  Core.TermApplication v0 -> Eithers.bind (recurse (Core.applicationFunction v0)) (\lhs -> Eithers.bind (recurse (Core.applicationArgument v0)) (\rhs -> Right (Core.TermApplication (Core.Application {+                    Core.applicationFunction = lhs,+                    Core.applicationArgument = rhs}))))+                  Core.TermCases v0 ->+                    let n = Core.caseStatementTypeName v0+                        def = Core.caseStatementDefault v0+                        csCases = Core.caseStatementCases v0+                    in (Eithers.bind (Optionals.cases def (Right Nothing) (\t -> Eithers.map Optionals.pure (recurse t))) (\rdef -> Eithers.map (\rcases -> Core.TermCases (Core.CaseStatement {+                      Core.caseStatementTypeName = n,+                      Core.caseStatementDefault = rdef,+                      Core.caseStatementCases = rcases})) (Eithers.mapList forCaseAlternative csCases)))+                  Core.TermEither v0 -> Eithers.bind (Eithers.either (\l -> Eithers.map (\x -> Left x) (recurse l)) (\r -> Eithers.map (\x -> Right x) (recurse r)) v0) (\re -> Right (Core.TermEither re))+                  Core.TermLambda v0 ->+                    let v = Core.lambdaParameter v0+                        d = Core.lambdaDomain v0+                        body = Core.lambdaBody v0+                    in (Eithers.bind (recurse body) (\rbody -> Right (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = v,+                      Core.lambdaDomain = d,+                      Core.lambdaBody = rbody}))))+                  Core.TermLet v0 ->+                    let bindings = Core.letBindings v0+                        env = Core.letBody v0+                    in (Eithers.bind (Eithers.mapList mapBinding bindings) (\rbindings -> Eithers.bind (recurse env) (\renv -> Right (Core.TermLet (Core.Let {+                      Core.letBindings = rbindings,+                      Core.letBody = renv})))))+                  Core.TermList v0 -> Eithers.bind (Eithers.mapList recurse v0) (\rels -> Right (Core.TermList rels))+                  Core.TermLiteral v0 -> Right (Core.TermLiteral v0)+                  Core.TermMap v0 -> Eithers.bind (Eithers.mapList forPair (Maps.toList v0)) (\pairs -> Right (Core.TermMap (Maps.fromList pairs)))+                  Core.TermOptional v0 -> Eithers.bind (Eithers.mapOptional recurse v0) (\rm -> Right (Core.TermOptional rm))+                  Core.TermPair v0 -> Eithers.bind (recurse (Pairs.first v0)) (\rf -> Eithers.bind (recurse (Pairs.second v0)) (\rs -> Right (Core.TermPair (rf, rs))))+                  Core.TermProject v0 -> Right (Core.TermProject v0)+                  Core.TermRecord v0 ->+                    let n = Core.recordTypeName v0+                        fields = Core.recordFields v0+                    in (Eithers.map (\rfields -> Core.TermRecord (Core.Record {+                      Core.recordTypeName = n,+                      Core.recordFields = rfields})) (Eithers.mapList forField fields))+                  Core.TermSet v0 -> Eithers.bind (Eithers.mapList recurse (Sets.toList v0)) (\rlist -> Right (Core.TermSet (Sets.fromList rlist)))+                  Core.TermTypeApplication v0 -> Eithers.bind (recurse (Core.typeApplicationTermBody v0)) (\t -> Right (Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = t,+                    Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})))+                  Core.TermTypeLambda v0 ->+                    let v = Core.typeLambdaParameter v0+                        body = Core.typeLambdaBody v0+                    in (Eithers.bind (recurse body) (\rbody -> Right (Core.TermTypeLambda (Core.TypeLambda {+                      Core.typeLambdaParameter = v,+                      Core.typeLambdaBody = rbody}))))+                  Core.TermInject v0 ->+                    let n = Core.injectionTypeName v0+                        field = Core.injectionField v0+                    in (Eithers.map (\rfield -> Core.TermInject (Core.Injection {+                      Core.injectionTypeName = n,+                      Core.injectionField = rfield})) (forField field))+                  Core.TermUnit -> Right Core.TermUnit+                  Core.TermUnwrap v0 -> Right (Core.TermUnwrap v0)+                  Core.TermVariable v0 -> Right (Core.TermVariable v0)+                  Core.TermWrap v0 ->+                    let name = Core.wrappedTermTypeName v0+                        t = Core.wrappedTermBody v0+                    in (Eithers.bind (recurse t) (\rt -> Right (Core.TermWrap (Core.WrappedTerm {+                      Core.wrappedTermTypeName = name,+                      Core.wrappedTermBody = rt}))))+          recurse = f (fsub recurse)+      in (recurse term0)+-- | A variant of rewriteTerm which allows a context (e.g. a TypeContext) to be passed down to all subterms during rewriting+rewriteTermWithContext :: ((t0 -> Core.Term -> Core.Term) -> t0 -> Core.Term -> Core.Term) -> t0 -> Core.Term -> Core.Term+rewriteTermWithContext f cx0 term0 =++      let forSubterms =+              \recurse0 -> \cx -> \term ->+                let recurse = recurse0 cx+                    forField =+                            \field -> Core.Field {+                              Core.fieldName = (Core.fieldName field),+                              Core.fieldTerm = (recurse (Core.fieldTerm field))}+                    forCaseAlternative =+                            \alt -> Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.caseAlternativeName alt),+                              Core.caseAlternativeHandler = (recurse (Core.caseAlternativeHandler alt))}+                    forLet =+                            \lt ->+                              let mapBinding =+                                      \b -> Core.Binding {+                                        Core.bindingName = (Core.bindingName b),+                                        Core.bindingTerm = (recurse (Core.bindingTerm b)),+                                        Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                              in Core.Let {+                                Core.letBindings = (Lists.map mapBinding (Core.letBindings lt)),+                                Core.letBody = (recurse (Core.letBody lt))}+                    forMap =+                            \m ->+                              let forPair = \p -> (recurse (Pairs.first p), (recurse (Pairs.second p)))+                              in (Maps.fromList (Lists.map forPair (Maps.toList m)))+                in case term of+                  Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {+                    Core.annotatedTermBody = (recurse (Core.annotatedTermBody v0)),+                    Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})+                  Core.TermApplication v0 -> Core.TermApplication (Core.Application {+                    Core.applicationFunction = (recurse (Core.applicationFunction v0)),+                    Core.applicationArgument = (recurse (Core.applicationArgument v0))})+                  Core.TermCases v0 -> Core.TermCases (Core.CaseStatement {+                    Core.caseStatementTypeName = (Core.caseStatementTypeName v0),+                    Core.caseStatementDefault = (Optionals.map recurse (Core.caseStatementDefault v0)),+                    Core.caseStatementCases = (Lists.map forCaseAlternative (Core.caseStatementCases v0))})+                  Core.TermEither v0 -> Core.TermEither (Eithers.either (\l -> Left (recurse l)) (\r -> Right (recurse r)) v0)+                  Core.TermLambda v0 -> Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.lambdaParameter v0),+                    Core.lambdaDomain = (Core.lambdaDomain v0),+                    Core.lambdaBody = (recurse (Core.lambdaBody v0))})+                  Core.TermLet v0 -> Core.TermLet (forLet v0)+                  Core.TermList v0 -> Core.TermList (Lists.map recurse v0)+                  Core.TermLiteral v0 -> Core.TermLiteral v0+                  Core.TermMap v0 -> Core.TermMap (forMap v0)+                  Core.TermOptional v0 -> Core.TermOptional (Optionals.map recurse v0)+                  Core.TermPair v0 -> Core.TermPair (recurse (Pairs.first v0), (recurse (Pairs.second v0)))+                  Core.TermProject v0 -> Core.TermProject v0+                  Core.TermRecord v0 -> Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.recordTypeName v0),+                    Core.recordFields = (Lists.map forField (Core.recordFields v0))})+                  Core.TermSet v0 -> Core.TermSet (Sets.fromList (Lists.map recurse (Sets.toList v0)))+                  Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = (recurse (Core.typeApplicationTermBody v0)),+                    Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})+                  Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda {+                    Core.typeLambdaParameter = (Core.typeLambdaParameter v0),+                    Core.typeLambdaBody = (recurse (Core.typeLambdaBody v0))})+                  Core.TermInject v0 -> Core.TermInject (Core.Injection {+                    Core.injectionTypeName = (Core.injectionTypeName v0),+                    Core.injectionField = (forField (Core.injectionField v0))})+                  Core.TermUnit -> Core.TermUnit+                  Core.TermUnwrap v0 -> Core.TermUnwrap v0+                  Core.TermVariable v0 -> Core.TermVariable v0+                  Core.TermWrap v0 -> Core.TermWrap (Core.WrappedTerm {+                    Core.wrappedTermTypeName = (Core.wrappedTermTypeName v0),+                    Core.wrappedTermBody = (recurse (Core.wrappedTermBody v0))})+          rewrite = \cx -> \term -> f (forSubterms rewrite) cx term+      in (rewrite cx0 term0)+-- | Either-based variant of rewriteTermWithContextM which allows a context (e.g. a TypeContext) to be passed down to all subterms during rewriting+rewriteTermWithContextM :: ((t0 -> Core.Term -> Either t1 Core.Term) -> t0 -> Core.Term -> Either t1 Core.Term) -> t0 -> Core.Term -> Either t1 Core.Term+rewriteTermWithContextM f cx0 term0 =++      let forSubterms =+              \recurse0 -> \cx -> \term ->+                let recurse = recurse0 cx+                    forField =+                            \field -> Eithers.bind (recurse (Core.fieldTerm field)) (\t -> Right (Core.Field {+                              Core.fieldName = (Core.fieldName field),+                              Core.fieldTerm = t}))+                    forCaseAlternative =+                            \alt -> Eithers.bind (recurse (Core.caseAlternativeHandler alt)) (\t -> Right (Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.caseAlternativeName alt),+                              Core.caseAlternativeHandler = t}))+                    forPair =+                            \kv -> Eithers.bind (recurse (Pairs.first kv)) (\k -> Eithers.bind (recurse (Pairs.second kv)) (\v -> Right (k, v)))+                    mapBinding =+                            \b -> Eithers.bind (recurse (Core.bindingTerm b)) (\v -> Right (Core.Binding {+                              Core.bindingName = (Core.bindingName b),+                              Core.bindingTerm = v,+                              Core.bindingTypeScheme = (Core.bindingTypeScheme b)}))+                in case term of+                  Core.TermAnnotated v0 -> Eithers.bind (recurse (Core.annotatedTermBody v0)) (\ex -> Right (Core.TermAnnotated (Core.AnnotatedTerm {+                    Core.annotatedTermBody = ex,+                    Core.annotatedTermAnnotation = (Core.annotatedTermAnnotation v0)})))+                  Core.TermApplication v0 -> Eithers.bind (recurse (Core.applicationFunction v0)) (\lhs -> Eithers.bind (recurse (Core.applicationArgument v0)) (\rhs -> Right (Core.TermApplication (Core.Application {+                    Core.applicationFunction = lhs,+                    Core.applicationArgument = rhs}))))+                  Core.TermCases v0 ->+                    let n = Core.caseStatementTypeName v0+                        def = Core.caseStatementDefault v0+                        csCases = Core.caseStatementCases v0+                    in (Eithers.bind (Optionals.cases def (Right Nothing) (\t -> Eithers.map Optionals.pure (recurse t))) (\rdef -> Eithers.map (\rcases -> Core.TermCases (Core.CaseStatement {+                      Core.caseStatementTypeName = n,+                      Core.caseStatementDefault = rdef,+                      Core.caseStatementCases = rcases})) (Eithers.mapList forCaseAlternative csCases)))+                  Core.TermEither v0 -> Eithers.bind (Eithers.either (\l -> Eithers.map (\x -> Left x) (recurse l)) (\r -> Eithers.map (\x -> Right x) (recurse r)) v0) (\re -> Right (Core.TermEither re))+                  Core.TermLambda v0 ->+                    let v = Core.lambdaParameter v0+                        d = Core.lambdaDomain v0+                        body = Core.lambdaBody v0+                    in (Eithers.bind (recurse body) (\rbody -> Right (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = v,+                      Core.lambdaDomain = d,+                      Core.lambdaBody = rbody}))))+                  Core.TermLet v0 ->+                    let bindings = Core.letBindings v0+                        body = Core.letBody v0+                    in (Eithers.bind (Eithers.mapList mapBinding bindings) (\rbindings -> Eithers.bind (recurse body) (\rbody -> Right (Core.TermLet (Core.Let {+                      Core.letBindings = rbindings,+                      Core.letBody = rbody})))))+                  Core.TermList v0 -> Eithers.bind (Eithers.mapList recurse v0) (\rels -> Right (Core.TermList rels))+                  Core.TermLiteral v0 -> Right (Core.TermLiteral v0)+                  Core.TermMap v0 -> Eithers.bind (Eithers.mapList forPair (Maps.toList v0)) (\pairs -> Right (Core.TermMap (Maps.fromList pairs)))+                  Core.TermOptional v0 -> Eithers.bind (Eithers.mapOptional recurse v0) (\rm -> Right (Core.TermOptional rm))+                  Core.TermPair v0 -> Eithers.bind (recurse (Pairs.first v0)) (\rfirst -> Eithers.bind (recurse (Pairs.second v0)) (\rsecond -> Right (Core.TermPair (rfirst, rsecond))))+                  Core.TermProject v0 -> Right (Core.TermProject v0)+                  Core.TermRecord v0 ->+                    let n = Core.recordTypeName v0+                        fields = Core.recordFields v0+                    in (Eithers.map (\rfields -> Core.TermRecord (Core.Record {+                      Core.recordTypeName = n,+                      Core.recordFields = rfields})) (Eithers.mapList forField fields))+                  Core.TermSet v0 -> Eithers.bind (Eithers.mapList recurse (Sets.toList v0)) (\rlist -> Right (Core.TermSet (Sets.fromList rlist)))+                  Core.TermTypeApplication v0 -> Eithers.bind (recurse (Core.typeApplicationTermBody v0)) (\t -> Right (Core.TermTypeApplication (Core.TypeApplicationTerm {+                    Core.typeApplicationTermBody = t,+                    Core.typeApplicationTermType = (Core.typeApplicationTermType v0)})))+                  Core.TermTypeLambda v0 ->+                    let v = Core.typeLambdaParameter v0+                        body = Core.typeLambdaBody v0+                    in (Eithers.bind (recurse body) (\rbody -> Right (Core.TermTypeLambda (Core.TypeLambda {+                      Core.typeLambdaParameter = v,+                      Core.typeLambdaBody = rbody}))))+                  Core.TermInject v0 ->+                    let n = Core.injectionTypeName v0+                        field = Core.injectionField v0+                    in (Eithers.map (\rfield -> Core.TermInject (Core.Injection {+                      Core.injectionTypeName = n,+                      Core.injectionField = rfield})) (forField field))+                  Core.TermUnit -> Right Core.TermUnit+                  Core.TermUnwrap v0 -> Right (Core.TermUnwrap v0)+                  Core.TermVariable v0 -> Right (Core.TermVariable v0)+                  Core.TermWrap v0 ->+                    let name = Core.wrappedTermTypeName v0+                        t = Core.wrappedTermBody v0+                    in (Eithers.bind (recurse t) (\rt -> Right (Core.TermWrap (Core.WrappedTerm {+                      Core.wrappedTermTypeName = name,+                      Core.wrappedTermBody = rt}))))+          rewrite = \cx -> \term -> f (forSubterms rewrite) cx term+      in (rewrite cx0 term0)+-- | Rewrite a term with the help of a Graph which is updated as we descend into subterms+rewriteTermWithGraph :: ((Core.Term -> t0) -> Graph.Graph -> Core.Term -> t0) -> Graph.Graph -> Core.Term -> t0+rewriteTermWithGraph f cx0 term0 =++      let f2 =+              \recurse -> \cx -> \term ->+                let recurse1 = \term2 -> recurse cx term2+                in case term of+                  Core.TermLambda v0 ->+                    let cx1 = Scoping.extendGraphForLambda cx v0+                        recurse2 = \term2 -> recurse cx1 term2+                    in (f recurse2 cx1 term)+                  Core.TermLet v0 ->+                    let cx1 = Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) cx v0+                        recurse2 = \term2 -> recurse cx1 term2+                    in (f recurse2 cx1 term)+                  Core.TermTypeLambda v0 ->+                    let cx1 = Scoping.extendGraphForTypeLambda cx v0+                        recurse2 = \term2 -> recurse cx1 term2+                    in (f recurse2 cx1 term)+                  _ -> f recurse1 cx term+          rewrite = \cx -> \term -> f2 rewrite cx term+      in (rewrite cx0 term0)+-- | Rewrite a type with a custom transformation function. The function receives a recursive walker and the current type and decides whether to recurse, replace, or both.+rewriteType :: ((Core.Type -> Core.Type) -> Core.Type -> Core.Type) -> Core.Type -> Core.Type+rewriteType f typ0 =++      let fsub =+              \recurse -> \typ ->+                let forField =+                        \field -> Core.FieldType {+                          Core.fieldTypeName = (Core.fieldTypeName field),+                          Core.fieldTypeType = (recurse (Core.fieldTypeType field))}+                in case typ of+                  Core.TypeAnnotated v0 -> Core.TypeAnnotated (Core.AnnotatedType {+                    Core.annotatedTypeBody = (recurse (Core.annotatedTypeBody v0)),+                    Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)})+                  Core.TypeApplication v0 -> Core.TypeApplication (Core.ApplicationType {+                    Core.applicationTypeFunction = (recurse (Core.applicationTypeFunction v0)),+                    Core.applicationTypeArgument = (recurse (Core.applicationTypeArgument v0))})+                  Core.TypeEither v0 -> Core.TypeEither (Core.EitherType {+                    Core.eitherTypeLeft = (recurse (Core.eitherTypeLeft v0)),+                    Core.eitherTypeRight = (recurse (Core.eitherTypeRight v0))})+                  Core.TypePair v0 -> Core.TypePair (Core.PairType {+                    Core.pairTypeFirst = (recurse (Core.pairTypeFirst v0)),+                    Core.pairTypeSecond = (recurse (Core.pairTypeSecond v0))})+                  Core.TypeFunction v0 -> Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (recurse (Core.functionTypeDomain v0)),+                    Core.functionTypeCodomain = (recurse (Core.functionTypeCodomain v0))})+                  Core.TypeForall v0 -> Core.TypeForall (Core.ForallType {+                    Core.forallTypeParameter = (Core.forallTypeParameter v0),+                    Core.forallTypeBody = (recurse (Core.forallTypeBody v0))})+                  Core.TypeList v0 -> Core.TypeList (recurse v0)+                  Core.TypeLiteral v0 -> Core.TypeLiteral v0+                  Core.TypeMap v0 -> Core.TypeMap (Core.MapType {+                    Core.mapTypeKeys = (recurse (Core.mapTypeKeys v0)),+                    Core.mapTypeValues = (recurse (Core.mapTypeValues v0))})+                  Core.TypeOptional v0 -> Core.TypeOptional (recurse v0)+                  Core.TypeRecord v0 -> Core.TypeRecord (Lists.map forField v0)+                  Core.TypeSet v0 -> Core.TypeSet (recurse v0)+                  Core.TypeUnion v0 -> Core.TypeUnion (Lists.map forField v0)+                  Core.TypeUnit -> Core.TypeUnit+                  Core.TypeVariable v0 -> Core.TypeVariable v0+                  Core.TypeVoid -> Core.TypeVoid+                  Core.TypeWrap v0 -> Core.TypeWrap (recurse v0)+          recurse = f (fsub recurse)+      in (recurse typ0)+-- | Either-based type rewriting+rewriteTypeM :: ((Core.Type -> Either t0 Core.Type) -> Core.Type -> Either t0 Core.Type) -> Core.Type -> Either t0 Core.Type+rewriteTypeM f typ0 =++      let fsub =+              \recurse -> \typ -> case typ of+                Core.TypeAnnotated v0 -> Eithers.bind (recurse (Core.annotatedTypeBody v0)) (\t -> Right (Core.TypeAnnotated (Core.AnnotatedType {+                  Core.annotatedTypeBody = t,+                  Core.annotatedTypeAnnotation = (Core.annotatedTypeAnnotation v0)})))+                Core.TypeApplication v0 -> Eithers.bind (recurse (Core.applicationTypeFunction v0)) (\lhs -> Eithers.bind (recurse (Core.applicationTypeArgument v0)) (\rhs -> Right (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = lhs,+                  Core.applicationTypeArgument = rhs}))))+                Core.TypeEither v0 -> Eithers.bind (recurse (Core.eitherTypeLeft v0)) (\left -> Eithers.bind (recurse (Core.eitherTypeRight v0)) (\right -> Right (Core.TypeEither (Core.EitherType {+                  Core.eitherTypeLeft = left,+                  Core.eitherTypeRight = right}))))+                Core.TypePair v0 -> Eithers.bind (recurse (Core.pairTypeFirst v0)) (\pairFirst -> Eithers.bind (recurse (Core.pairTypeSecond v0)) (\pairSecond -> Right (Core.TypePair (Core.PairType {+                  Core.pairTypeFirst = pairFirst,+                  Core.pairTypeSecond = pairSecond}))))+                Core.TypeFunction v0 -> Eithers.bind (recurse (Core.functionTypeDomain v0)) (\dom -> Eithers.bind (recurse (Core.functionTypeCodomain v0)) (\cod -> Right (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = dom,+                  Core.functionTypeCodomain = cod}))))+                Core.TypeForall v0 -> Eithers.bind (recurse (Core.forallTypeBody v0)) (\b -> Right (Core.TypeForall (Core.ForallType {+                  Core.forallTypeParameter = (Core.forallTypeParameter v0),+                  Core.forallTypeBody = b})))+                Core.TypeList v0 -> Eithers.bind (recurse v0) (\rt -> Right (Core.TypeList rt))+                Core.TypeLiteral v0 -> Right (Core.TypeLiteral v0)+                Core.TypeMap v0 -> Eithers.bind (recurse (Core.mapTypeKeys v0)) (\kt -> Eithers.bind (recurse (Core.mapTypeValues v0)) (\vt -> Right (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = kt,+                  Core.mapTypeValues = vt}))))+                Core.TypeOptional v0 -> Eithers.bind (recurse v0) (\rt -> Right (Core.TypeOptional rt))+                Core.TypeRecord v0 ->+                  let forField =+                          \f2 -> Eithers.bind (recurse (Core.fieldTypeType f2)) (\t -> Right (Core.FieldType {+                            Core.fieldTypeName = (Core.fieldTypeName f2),+                            Core.fieldTypeType = t}))+                  in (Eithers.bind (Eithers.mapList forField v0) (\rfields -> Right (Core.TypeRecord rfields)))+                Core.TypeSet v0 -> Eithers.bind (recurse v0) (\rt -> Right (Core.TypeSet rt))+                Core.TypeUnion v0 ->+                  let forField =+                          \f2 -> Eithers.bind (recurse (Core.fieldTypeType f2)) (\t -> Right (Core.FieldType {+                            Core.fieldTypeName = (Core.fieldTypeName f2),+                            Core.fieldTypeType = t}))+                  in (Eithers.bind (Eithers.mapList forField v0) (\rfields -> Right (Core.TypeUnion rfields)))+                Core.TypeUnit -> Right Core.TypeUnit+                Core.TypeVariable v0 -> Right (Core.TypeVariable v0)+                Core.TypeVoid -> Right Core.TypeVoid+                Core.TypeWrap v0 -> Eithers.bind (recurse v0) (\t -> Right (Core.TypeWrap t))+          recurse = f (fsub recurse)+      in (recurse typ0)+-- | Find the children of a given term+subterms :: Core.Term -> [Core.Term]+subterms x =+    case x of+      Core.TermAnnotated v0 -> [+        Core.annotatedTermBody v0]+      Core.TermApplication v0 -> [+        Core.applicationFunction v0,+        (Core.applicationArgument v0)]+      Core.TermCases v0 -> Lists.concat2 (Optionals.cases (Core.caseStatementDefault v0) [] (\t -> [+        t])) (Lists.map Core.caseAlternativeHandler (Core.caseStatementCases v0))+      Core.TermEither v0 -> Eithers.either (\l -> [+        l]) (\r -> [+        r]) v0+      Core.TermLambda v0 -> [+        Core.lambdaBody v0]+      Core.TermLet v0 -> Lists.cons (Core.letBody v0) (Lists.map Core.bindingTerm (Core.letBindings v0))+      Core.TermList v0 -> v0+      Core.TermLiteral _ -> []+      Core.TermMap v0 -> Lists.concat (Lists.map (\p -> [+        Pairs.first p,+        (Pairs.second p)]) (Maps.toList v0))+      Core.TermOptional v0 -> Optionals.cases v0 [] (\t -> [+        t])+      Core.TermPair v0 -> [+        Pairs.first v0,+        (Pairs.second v0)]+      Core.TermProject _ -> []+      Core.TermRecord v0 -> Lists.map Core.fieldTerm (Core.recordFields v0)+      Core.TermSet v0 -> Sets.toList v0+      Core.TermTypeApplication v0 -> [+        Core.typeApplicationTermBody v0]+      Core.TermTypeLambda v0 -> [+        Core.typeLambdaBody v0]+      Core.TermInject v0 -> [+        Core.fieldTerm (Core.injectionField v0)]+      Core.TermUnit -> []+      Core.TermUnwrap _ -> []+      Core.TermVariable _ -> []+      Core.TermWrap v0 -> [+        Core.wrappedTermBody v0]+-- | Find the children of a given term+subtermsWithSteps :: Core.Term -> [(Paths.SubtermStep, Core.Term)]+subtermsWithSteps x =+    case x of+      Core.TermAnnotated v0 -> [+        (Paths.SubtermStepAnnotatedBody, (Core.annotatedTermBody v0))]+      Core.TermApplication v0 -> [+        (Paths.SubtermStepApplicationFunction, (Core.applicationFunction v0)),+        (Paths.SubtermStepApplicationArgument, (Core.applicationArgument v0))]+      Core.TermCases v0 -> Lists.concat2 (Optionals.cases (Core.caseStatementDefault v0) [] (\t -> [+        (Paths.SubtermStepUnionCasesDefault, t)])) (Lists.map (\f -> (Paths.SubtermStepUnionCasesBranch (Core.caseAlternativeName f), (Core.caseAlternativeHandler f))) (Core.caseStatementCases v0))+      Core.TermEither _ -> []+      Core.TermLambda v0 -> [+        (Paths.SubtermStepLambdaBody, (Core.lambdaBody v0))]+      Core.TermLet v0 -> Lists.cons (Paths.SubtermStepLetBody, (Core.letBody v0)) (Lists.map (\b -> (Paths.SubtermStepLetBinding (Core.bindingName b), (Core.bindingTerm b))) (Core.letBindings v0))+      Core.TermList v0 -> Lists.map (\e -> (Paths.SubtermStepListElement 0, e)) v0+      Core.TermLiteral _ -> []+      Core.TermMap v0 -> Lists.concat (Lists.map (\p -> [+        (Paths.SubtermStepMapKey 0, (Pairs.first p)),+        (Paths.SubtermStepMapValue 0, (Pairs.second p))]) (Maps.toList v0))+      Core.TermOptional v0 -> Optionals.cases v0 [] (\t -> [+        (Paths.SubtermStepOptionalTerm, t)])+      Core.TermPair _ -> []+      Core.TermProject _ -> []+      Core.TermRecord v0 -> Lists.map (\f -> (Paths.SubtermStepRecordField (Core.fieldName f), (Core.fieldTerm f))) (Core.recordFields v0)+      Core.TermSet v0 -> Lists.map (\e -> (Paths.SubtermStepListElement 0, e)) (Sets.toList v0)+      Core.TermTypeApplication v0 -> [+        (Paths.SubtermStepTypeApplicationTerm, (Core.typeApplicationTermBody v0))]+      Core.TermTypeLambda v0 -> [+        (Paths.SubtermStepTypeLambdaBody, (Core.typeLambdaBody v0))]+      Core.TermInject v0 -> [+        (Paths.SubtermStepInjectionTerm, (Core.fieldTerm (Core.injectionField v0)))]+      Core.TermUnit -> []+      Core.TermUnwrap _ -> []+      Core.TermVariable _ -> []+      Core.TermWrap v0 -> [+        (Paths.SubtermStepWrappedTerm, (Core.wrappedTermBody v0))]+-- | Find the children of a given type expression+subtypes :: Core.Type -> [Core.Type]+subtypes x =+    case x of+      Core.TypeAnnotated v0 -> [+        Core.annotatedTypeBody v0]+      Core.TypeApplication v0 -> [+        Core.applicationTypeFunction v0,+        (Core.applicationTypeArgument v0)]+      Core.TypeEither v0 -> [+        Core.eitherTypeLeft v0,+        (Core.eitherTypeRight v0)]+      Core.TypePair v0 -> [+        Core.pairTypeFirst v0,+        (Core.pairTypeSecond v0)]+      Core.TypeFunction v0 -> [+        Core.functionTypeDomain v0,+        (Core.functionTypeCodomain v0)]+      Core.TypeForall v0 -> [+        Core.forallTypeBody v0]+      Core.TypeList v0 -> [+        v0]+      Core.TypeLiteral _ -> []+      Core.TypeMap v0 -> [+        Core.mapTypeKeys v0,+        (Core.mapTypeValues v0)]+      Core.TypeOptional v0 -> [+        v0]+      Core.TypeRecord v0 -> Lists.map Core.fieldTypeType v0+      Core.TypeSet v0 -> [+        v0]+      Core.TypeUnion v0 -> Lists.map Core.fieldTypeType v0+      Core.TypeUnit -> []+      Core.TypeVariable _ -> []+      Core.TypeVoid -> []+      Core.TypeWrap v0 -> [+        v0]
+ src/main/haskell/Hydra/Scoping.hs view
@@ -0,0 +1,194 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Graph context extension and type scheme conversion++module Hydra.Scoping where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Extend a graph by descending into a lambda body+extendGraphForLambda :: Graph.Graph -> Core.Lambda -> Graph.Graph+extendGraphForLambda g lam =++      let var = Core.lambdaParameter lam+      in Graph.Graph {+        Graph.graphBoundTerms = (Graph.graphBoundTerms g),+        Graph.graphBoundTypes = (Optionals.cases (Core.lambdaDomain lam) (Graph.graphBoundTypes g) (\dom -> Maps.insert var (fTypeToTypeScheme dom) (Graph.graphBoundTypes g))),+        Graph.graphClassConstraints = (Graph.graphClassConstraints g),+        Graph.graphLambdaVariables = (Sets.insert var (Graph.graphLambdaVariables g)),+        Graph.graphMetadata = (Maps.delete var (Graph.graphMetadata g)),+        Graph.graphPrimitives = (Graph.graphPrimitives g),+        Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),+        Graph.graphTypeVariables = (Graph.graphTypeVariables g)}+-- | Extend a graph by descending into a let body+extendGraphForLet :: (Graph.Graph -> Core.Binding -> Maybe Core.Term) -> Graph.Graph -> Core.Let -> Graph.Graph+extendGraphForLet forBinding g letrec =++      let bindings = Core.letBindings letrec+          g2 = extendGraphWithBindings bindings g+      in Graph.Graph {+        Graph.graphBoundTerms = (Maps.union (Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) bindings)) (Graph.graphBoundTerms g)),+        Graph.graphBoundTypes = (Maps.union (Maps.fromList (Optionals.cat (Lists.map (\b -> Optionals.map (\ts -> (Core.bindingName b, ts)) (Core.bindingTypeScheme b)) bindings))) (Graph.graphBoundTypes g)),+        Graph.graphClassConstraints = (Graph.graphClassConstraints g),+        Graph.graphLambdaVariables = (Lists.foldl (\s -> \b -> Sets.delete (Core.bindingName b) s) (Graph.graphLambdaVariables g) bindings),+        Graph.graphMetadata = (Graph.graphMetadata (Lists.foldl (\gAcc -> \b ->+          let m = Graph.graphMetadata gAcc+              newMeta = Optionals.cases (forBinding gAcc b) (Maps.delete (Core.bindingName b) m) (\t -> Maps.insert (Core.bindingName b) t m)+          in Graph.Graph {+            Graph.graphBoundTerms = (Graph.graphBoundTerms gAcc),+            Graph.graphBoundTypes = (Graph.graphBoundTypes gAcc),+            Graph.graphClassConstraints = (Graph.graphClassConstraints gAcc),+            Graph.graphLambdaVariables = (Graph.graphLambdaVariables gAcc),+            Graph.graphMetadata = newMeta,+            Graph.graphPrimitives = (Graph.graphPrimitives gAcc),+            Graph.graphSchemaTypes = (Graph.graphSchemaTypes gAcc),+            Graph.graphTypeVariables = (Graph.graphTypeVariables gAcc)}) g2 bindings)),+        Graph.graphPrimitives = (Graph.graphPrimitives g),+        Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),+        Graph.graphTypeVariables = (Graph.graphTypeVariables g)}+-- | Extend a graph by descending into a type lambda body+extendGraphForTypeLambda :: Graph.Graph -> Core.TypeLambda -> Graph.Graph+extendGraphForTypeLambda g tlam =++      let name = Core.typeLambdaParameter tlam+      in Graph.Graph {+        Graph.graphBoundTerms = (Graph.graphBoundTerms g),+        Graph.graphBoundTypes = (Graph.graphBoundTypes g),+        Graph.graphClassConstraints = (Graph.graphClassConstraints g),+        Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),+        Graph.graphMetadata = (Graph.graphMetadata g),+        Graph.graphPrimitives = (Graph.graphPrimitives g),+        Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),+        Graph.graphTypeVariables = (Sets.insert name (Graph.graphTypeVariables g))}+-- | Add bindings to an existing graph+extendGraphWithBindings :: [Core.Binding] -> Graph.Graph -> Graph.Graph+extendGraphWithBindings bindings g =++      let newTerms = Maps.fromList (Lists.map (\b -> (Core.bindingName b, (Core.bindingTerm b))) bindings)+          newTypes =+                  Maps.fromList (Optionals.cat (Lists.map (\b -> Optionals.map (\ts -> (Core.bindingName b, ts)) (Core.bindingTypeScheme b)) bindings))+      in Graph.Graph {+        Graph.graphBoundTerms = (Maps.union newTerms (Graph.graphBoundTerms g)),+        Graph.graphBoundTypes = (Maps.union newTypes (Graph.graphBoundTypes g)),+        Graph.graphClassConstraints = (Graph.graphClassConstraints g),+        Graph.graphLambdaVariables = (Graph.graphLambdaVariables g),+        Graph.graphMetadata = (Graph.graphMetadata g),+        Graph.graphPrimitives = (Graph.graphPrimitives g),+        Graph.graphSchemaTypes = (Graph.graphSchemaTypes g),+        Graph.graphTypeVariables = (Graph.graphTypeVariables g)}+-- | Convert a forall type to a type scheme+fTypeToTypeScheme :: Core.Type -> Core.TypeScheme+fTypeToTypeScheme typ =++      let stripAnnotations =+              \t -> case t of+                Core.TypeAnnotated v0 -> stripAnnotations (Core.annotatedTypeBody v0)+                _ -> t+          gatherForall =+                  \vars -> \typ2 -> case (stripAnnotations typ2) of+                    Core.TypeForall v0 -> gatherForall (Lists.cons (Core.forallTypeParameter v0) vars) (Core.forallTypeBody v0)+                    _ -> Core.TypeScheme {+                      Core.typeSchemeVariables = (Lists.reverse vars),+                      Core.typeSchemeBody = typ2,+                      Core.typeSchemeConstraints = Nothing}+      in (gatherForall [] typ)+-- | Convert a TermSignature to a TypeScheme, erasing parameter names, descriptions, and laziness flags.+termSignatureToTypeScheme :: Typing.TermSignature -> Core.TypeScheme+termSignatureToTypeScheme sig =++      let typeParams = Typing.termSignatureTypeParameters sig+          params = Typing.termSignatureParameters sig+          result = Typing.termSignatureResult sig+          variables = Lists.map (\tp -> Typing.typeParameterName tp) typeParams+          body =+                  Lists.foldl (\acc -> \p -> Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Typing.parameterType p),+                    Core.functionTypeCodomain = acc})) (Typing.resultType result) (Lists.reverse params)+          hasConstraints =+                  Lists.foldl (\acc -> \tp -> Logic.or acc (Logic.not (Lists.null (Typing.typeParameterConstraints tp)))) False typeParams+          constraints =+                  Logic.ifElse hasConstraints (Just (Maps.fromList (Lists.map (\tp -> (+                    Typing.typeParameterName tp,+                    Core.TypeVariableConstraints {+                      Core.typeVariableConstraintsClasses = (Typing.typeParameterConstraints tp)})) typeParams))) Nothing+      in Core.TypeScheme {+        Core.typeSchemeVariables = variables,+        Core.typeSchemeBody = body,+        Core.typeSchemeConstraints = constraints}+-- | Convert a type scheme to a forall type+typeSchemeToFType :: Core.TypeScheme -> Core.Type+typeSchemeToFType ts =++      let vars = Core.typeSchemeVariables ts+          body = Core.typeSchemeBody ts+      in (Lists.foldl (\t -> \v -> Core.TypeForall (Core.ForallType {+        Core.forallTypeParameter = v,+        Core.forallTypeBody = t})) body (Lists.reverse vars))+-- | Convert a TypeScheme to a TermSignature. Type variables and class constraints are preserved exactly. Value-parameter names are synthesized as arg0, arg1, .... Per-parameter descriptions are nothing and isLazy defaults to false.+typeSchemeToTermSignature :: Core.TypeScheme -> Typing.TermSignature+typeSchemeToTermSignature ts =++      let variables = Core.typeSchemeVariables ts+          body = Core.typeSchemeBody ts+          constraintsMap = Optionals.fromOptional Maps.empty (Core.typeSchemeConstraints ts)+          typeParams =+                  Lists.map (\v -> Typing.TypeParameter {+                    Typing.typeParameterName = v,+                    Typing.typeParameterConstraints = (Optionals.cases (Maps.lookup v constraintsMap) [] (\tvm -> Core.typeVariableConstraintsClasses tvm))}) variables+          peel =+                  \acc -> \t -> case t of+                    Core.TypeFunction v0 -> peel (Lists.cons (Core.functionTypeDomain v0) acc) (Core.functionTypeCodomain v0)+                    _ -> (Lists.reverse acc, t)+          peeled = peel [] body+          paramTypes = Pairs.first peeled+          resultType = Pairs.second peeled+          params =+                  Lists.reverse (Pairs.first (Lists.foldl (\acc -> \ty ->+                    let pairAcc = Pairs.first acc+                        i = Pairs.second acc+                    in (+                      Lists.cons (Typing.Parameter {+                        Typing.parameterName = (Core.Name (Strings.cat [+                          "arg",+                          (Literals.showInt32 i)])),+                        Typing.parameterDescription = Nothing,+                        Typing.parameterType = ty,+                        Typing.parameterIsLazy = False}) pairAcc,+                      (Math.add i 1))) ([], 0) paramTypes))+          result =+                  Typing.Result {+                    Typing.resultDescription = Nothing,+                    Typing.resultType = resultType}+      in Typing.TermSignature {+        Typing.termSignatureTypeParameters = typeParams,+        Typing.termSignatureParameters = params,+        Typing.termSignatureResult = result}
+ src/main/haskell/Hydra/Serialization.hs view
@@ -0,0 +1,590 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Utilities for constructing generic program code ASTs, used for the serialization phase of source code generation.++module Hydra.Serialization where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Math as Math+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Angle bracket pair `<` `>` for use with `brackets`+angleBraces :: Ast.Brackets+angleBraces =+    Ast.Brackets {+      Ast.bracketsOpen = (Ast.Symbol "<"),+      Ast.bracketsClose = (Ast.Symbol ">")}+-- | Comma-separate the elements inside angle brackets in the given block style; renders as `<>` when empty+angleBracesList :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr+angleBracesList style els = Logic.ifElse (Lists.null els) (cst "<>") (brackets angleBraces style (commaSep style els))+-- | Produce a bracketed list which separates elements by spaces or newlines depending on the estimated width of the expression.+bracesListAdaptive :: [Ast.Expr] -> Ast.Expr+bracesListAdaptive els =+    chooseLayout maxLineWidth (curlyBracesList Nothing inlineStyle els) (curlyBracesList Nothing halfBlockStyle els)+-- | Comma-separate the elements inside square brackets in the given block style; renders as `[]` when empty+bracketList :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr+bracketList style els = Logic.ifElse (Lists.null els) (cst "[]") (brackets squareBrackets style (commaSep style els))+-- | Produce a bracketed list which separates elements by spaces or newlines depending on the estimated width of the expression.+bracketListAdaptive :: [Ast.Expr] -> Ast.Expr+bracketListAdaptive els = chooseLayout maxLineWidth (bracketList inlineStyle els) (bracketList halfBlockStyle els)+-- | Wrap an expression in the given bracket pair using the given block style+brackets :: Ast.Brackets -> Ast.BlockStyle -> Ast.Expr -> Ast.Expr+brackets br style e =+    Ast.ExprBrackets (Ast.BracketExpr {+      Ast.bracketExprBrackets = br,+      Ast.bracketExprEnclosed = e,+      Ast.bracketExprStyle = style})+-- | Pick between an inline and a multi-line layout for the same logical expression. Returns the inline form if its estimated width does not exceed the threshold, otherwise the block form. Note: the threshold is measured against the inline expression in isolation; surrounding indentation may push content beyond the threshold at print time. Callers that know they are nested can pass a smaller threshold to compensate.+chooseLayout :: Int -> Ast.Expr -> Ast.Expr -> Ast.Expr+chooseLayout threshold inlineExpr blockExpr =+    Logic.ifElse (Equality.gt (expressionLength inlineExpr) threshold) blockExpr inlineExpr+-- | Separate elements with a comma, using the given block style+commaSep :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr+commaSep = symbolSep ","+-- | Comma-separate elements inline if the joined width fits, otherwise break onto separate lines.+commaSepAdaptive :: [Ast.Expr] -> Ast.Expr+commaSepAdaptive els = chooseLayout maxLineWidth (commaSep inlineStyle els) (commaSep halfBlockStyle els)+-- | Construct a constant expression from a literal string+cst :: String -> Ast.Expr+cst s = Ast.ExprConst (sym s)+-- | Wrap a single expression in curly braces using the given block style+curlyBlock :: Ast.BlockStyle -> Ast.Expr -> Ast.Expr+curlyBlock style e = curlyBracesList Nothing style [+  e]+-- | Curly brace pair `{` `}` for use with `brackets`+curlyBraces :: Ast.Brackets+curlyBraces =+    Ast.Brackets {+      Ast.bracketsOpen = (Ast.Symbol "{"),+      Ast.bracketsClose = (Ast.Symbol "}")}+-- | Separate the elements inside curly braces using the given symbol (default `,`) in the given block style; renders as `{}` when empty+curlyBracesList :: Maybe String -> Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr+curlyBracesList msymb style els =+    Logic.ifElse (Lists.null els) (cst "{}") (brackets curlyBraces style (symbolSep (Optionals.fromOptional "," msymb) style els))+-- | Indent every non-empty line of `s` by `idt`. Empty lines stay empty (no trailing whitespace) so downstream byte-identity checks don't care about indent depth.+customIndent :: String -> String -> String+customIndent idt s =+    Strings.cat (Lists.intersperse "\n" (Lists.map (\line -> Logic.ifElse (Equality.equal line "") line (Strings.cat2 idt line)) (Strings.lines s)))+-- | Render a list of expressions as a block whose first element starts where the surrounding context placed it and subsequent elements break onto fresh lines indented by the given prefix+customIndentBlock :: String -> [Ast.Expr] -> Ast.Expr+customIndentBlock idt els =++      let idtOp =+              Ast.Op {+                Ast.opSymbol = (sym ""),+                Ast.opPadding = Ast.Padding {+                  Ast.paddingLeft = Ast.WsSpace,+                  Ast.paddingRight = (Ast.WsBreakAndIndent idt)},+                Ast.opPrecedence = (Ast.Precedence 0),+                Ast.opAssociativity = Ast.AssociativityNone}+      in (Optionals.cases (Lists.maybeHead els) (cst "") (\head -> Logic.ifElse (Equality.equal (Lists.length els) 1) head (ifx idtOp head (newlineSep (Lists.drop 1 els)))))+-- | Separate elements with a dot and no surrounding whitespace+dotSep :: [Ast.Expr] -> Ast.Expr+dotSep =+    sep (Ast.Op {+      Ast.opSymbol = (sym "."),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsNone,+        Ast.paddingRight = Ast.WsNone},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone})+-- | Separate elements with a blank line between them+doubleNewlineSep :: [Ast.Expr] -> Ast.Expr+doubleNewlineSep =+    sep (Ast.Op {+      Ast.opSymbol = (sym ""),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsBreak,+        Ast.paddingRight = Ast.WsBreak},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone})+-- | The two-space string used as the canonical indent unit+doubleSpace :: String+doubleSpace = "  "+-- | Find the approximate length (number of characters, including spaces and newlines) of an expression without actually printing it.+expressionLength :: Ast.Expr -> Int+expressionLength e =++      let symbolLength = \s -> Strings.length (Ast.unSymbol s)+          wsLength =+                  \ws -> case ws of+                    Ast.WsNone -> 0+                    Ast.WsSpace -> 1+                    Ast.WsBreak -> 10000+                    Ast.WsBreakAndIndent _ -> 10000+                    Ast.WsDoubleBreak -> 10000+          blockStyleLength =+                  \style ->+                    let mindentLen = Optionals.cases (Ast.blockStyleIndent style) 0 Strings.length+                        nlBeforeLen = Logic.ifElse (Ast.blockStyleNewlineBeforeContent style) 1 0+                        nlAfterLen = Logic.ifElse (Ast.blockStyleNewlineAfterContent style) 1 0+                    in (Math.add mindentLen (Math.add nlBeforeLen nlAfterLen))+          bracketsLength =+                  \brackets -> Math.add (symbolLength (Ast.bracketsOpen brackets)) (symbolLength (Ast.bracketsClose brackets))+          bracketExprLength =+                  \be -> Math.add (bracketsLength (Ast.bracketExprBrackets be)) (Math.add (expressionLength (Ast.bracketExprEnclosed be)) (blockStyleLength (Ast.bracketExprStyle be)))+          indentedExpressionLength =+                  \ie ->+                    let baseLen = expressionLength (Ast.indentedExpressionExpr ie)+                        indentLen =+                                case (Ast.indentedExpressionStyle ie) of+                                  Ast.IndentStyleAllLines v0 -> Strings.length v0+                                  Ast.IndentStyleSubsequentLines v0 -> Strings.length v0+                    in (Math.add baseLen indentLen)+          opLength =+                  \op ->+                    let symLen = symbolLength (Ast.opSymbol op)+                        padding = Ast.opPadding op+                        leftLen = wsLength (Ast.paddingLeft padding)+                        rightLen = wsLength (Ast.paddingRight padding)+                    in (Math.add symLen (Math.add leftLen rightLen))+          opExprLength =+                  \oe ->+                    let opLen = opLength (Ast.opExprOp oe)+                        leftLen = expressionLength (Ast.opExprLhs oe)+                        rightLen = expressionLength (Ast.opExprRhs oe)+                    in (Math.add opLen (Math.add leftLen rightLen))+          seqExprLength =+                  \se ->+                    let sopLen = opLength (Ast.seqExprOp se)+                        elementLens = Lists.map expressionLength (Ast.seqExprElements se)+                        totalElLen = Lists.foldl Math.add 0 elementLens+                        numSeps = Math.sub (Lists.length (Ast.seqExprElements se)) 1+                    in (Math.add totalElLen (Math.mul sopLen (Logic.ifElse (Equality.gt numSeps 0) numSeps 0)))+      in case e of+        Ast.ExprConst v0 -> symbolLength v0+        Ast.ExprIndent v0 -> indentedExpressionLength v0+        Ast.ExprOp v0 -> opExprLength v0+        Ast.ExprBrackets v0 -> bracketExprLength v0+        Ast.ExprSeq v0 -> seqExprLength v0+-- | Block style with double-space indent and newlines both before and after the bracketed content+fullBlockStyle :: Ast.BlockStyle+fullBlockStyle =+    Ast.BlockStyle {+      Ast.blockStyleIndent = (Just doubleSpace),+      Ast.blockStyleNewlineBeforeContent = True,+      Ast.blockStyleNewlineAfterContent = True}+-- | Block style with double-space indent, a newline before the content but not after+halfBlockStyle :: Ast.BlockStyle+halfBlockStyle =+    Ast.BlockStyle {+      Ast.blockStyleIndent = (Just doubleSpace),+      Ast.blockStyleNewlineBeforeContent = True,+      Ast.blockStyleNewlineAfterContent = False}+-- | Build an infix expression with the given operator and two operands+ifx :: Ast.Op -> Ast.Expr -> Ast.Expr -> Ast.Expr+ifx op lhs rhs =+    Ast.ExprOp (Ast.OpExpr {+      Ast.opExprOp = op,+      Ast.opExprLhs = lhs,+      Ast.opExprRhs = rhs})+-- | Indent every non-empty line of a string by `doubleSpace`+indent :: String -> String+indent = customIndent doubleSpace+-- | Like `customIndentBlock`, but using `doubleSpace` as the indent prefix+indentBlock :: [Ast.Expr] -> Ast.Expr+indentBlock = customIndentBlock doubleSpace+-- | Indent every line of an expression except the first by the given prefix+indentSubsequentLines :: String -> Ast.Expr -> Ast.Expr+indentSubsequentLines idt e =+    Ast.ExprIndent (Ast.IndentedExpression {+      Ast.indentedExpressionStyle = (Ast.IndentStyleSubsequentLines idt),+      Ast.indentedExpressionExpr = e})+-- | Space-separate three elements: left operand, operator string, right operand+infixWs :: String -> Ast.Expr -> Ast.Expr -> Ast.Expr+infixWs op l r =+    spaceSep [+      l,+      (cst op),+      r]+-- | Space-separate operands interleaved with the given operator string+infixWsList :: String -> [Ast.Expr] -> Ast.Expr+infixWsList op opers =++      let opExpr = cst op+          foldFun = \e -> \r -> Logic.ifElse (Lists.null e) [+                r] (Lists.cons r (Lists.cons opExpr e))+      in (spaceSep (Lists.foldl foldFun [] (Lists.reverse opers)))+-- | Block style with no indent and no surrounding newlines: contents stay on a single line+inlineStyle :: Ast.BlockStyle+inlineStyle =+    Ast.BlockStyle {+      Ast.blockStyleIndent = Nothing,+      Ast.blockStyleNewlineBeforeContent = False,+      Ast.blockStyleNewlineAfterContent = False}+-- | The canonical maximum line width used by Hydra writers. Adaptive helpers compare estimated expression widths against this threshold to decide whether to render inline or break across lines. Set to 120 to match the project-wide line-length convention.+maxLineWidth :: Int+maxLineWidth = 120+-- | Separate elements by a newline (no leading whitespace)+newlineSep :: [Ast.Expr] -> Ast.Expr+newlineSep =+    sep (Ast.Op {+      Ast.opSymbol = (sym ""),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsNone,+        Ast.paddingRight = Ast.WsBreak},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone})+-- | Operator padding with no whitespace on either side+noPadding :: Ast.Padding+noPadding =+    Ast.Padding {+      Ast.paddingLeft = Ast.WsNone,+      Ast.paddingRight = Ast.WsNone}+-- | Concatenate elements with no separator and no whitespace+noSep :: [Ast.Expr] -> Ast.Expr+noSep =+    sep (Ast.Op {+      Ast.opSymbol = (sym ""),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsNone,+        Ast.paddingRight = Ast.WsNone},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone})+-- | Construct a constant expression from an int32+num :: Int -> Ast.Expr+num i = cst (Literals.showInt32 i)+-- | Build an op with single-space padding from a symbol, precedence, and associativity+op :: String -> Int -> Ast.Associativity -> Ast.Op+op s p assoc =+    Ast.Op {+      Ast.opSymbol = (sym s),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsSpace,+        Ast.paddingRight = Ast.WsSpace},+      Ast.opPrecedence = (Ast.Precedence p),+      Ast.opAssociativity = assoc}+-- | Build the `|` alternative-separator operator. The flag selects whether the right side breaks onto a new line.+orOp :: Bool -> Ast.Op+orOp newlines =+    Ast.Op {+      Ast.opSymbol = (sym "|"),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsSpace,+        Ast.paddingRight = (Logic.ifElse newlines Ast.WsBreak Ast.WsSpace)},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone}+-- | Separate alternatives with `|`, breaking onto separate lines when the block style requests a newline before content+orSep :: Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr+orSep style l =++      let newlines = Ast.blockStyleNewlineBeforeContent style+      in (Optionals.cases (Lists.maybeHead l) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx (orOp newlines) acc el) h (Lists.drop 1 l)))+-- | Comma-separate the elements inside parentheses; switches to a half-block style when newlines are requested and there is more than one element. Renders as `()` when empty.+parenList :: Bool -> [Ast.Expr] -> Ast.Expr+parenList newlines els =++      let style = Logic.ifElse (Logic.and newlines (Equality.gt (Lists.length els) 1)) halfBlockStyle inlineStyle+      in (Logic.ifElse (Lists.null els) (cst "()") (brackets parentheses style (commaSep style els)))+-- | Produce a parenthesized list which separates elements by spaces or newlines depending on the estimated width of the expression.+parenListAdaptive :: [Ast.Expr] -> Ast.Expr+parenListAdaptive els = chooseLayout maxLineWidth (parenList False els) (parenList True els)+-- | Wrap an expression in inline parentheses+parens :: Ast.Expr -> Ast.Expr+parens = brackets parentheses inlineStyle+-- | Round parenthesis pair `(` `)` for use with `brackets`+parentheses :: Ast.Brackets+parentheses =+    Ast.Brackets {+      Ast.bracketsOpen = (Ast.Symbol "("),+      Ast.bracketsClose = (Ast.Symbol ")")}+-- | Recursively insert parentheses around subexpressions where required by operator precedence and associativity. The traversal descends into bracket, indent, sequence, and operator expressions and parenthesizes left or right operands whose binding is weaker than the surrounding operator.+parenthesize :: Ast.Expr -> Ast.Expr+parenthesize exp =++      let assocLeft =+              \a -> case a of+                Ast.AssociativityRight -> False+                _ -> True+          assocRight =+                  \a -> case a of+                    Ast.AssociativityLeft -> False+                    _ -> True+      in case exp of+        Ast.ExprBrackets v0 -> Ast.ExprBrackets (Ast.BracketExpr {+          Ast.bracketExprBrackets = (Ast.bracketExprBrackets v0),+          Ast.bracketExprEnclosed = (parenthesize (Ast.bracketExprEnclosed v0)),+          Ast.bracketExprStyle = (Ast.bracketExprStyle v0)})+        Ast.ExprConst _ -> exp+        Ast.ExprIndent v0 -> Ast.ExprIndent (Ast.IndentedExpression {+          Ast.indentedExpressionStyle = (Ast.indentedExpressionStyle v0),+          Ast.indentedExpressionExpr = (parenthesize (Ast.indentedExpressionExpr v0))})+        Ast.ExprSeq v0 -> Ast.ExprSeq (Ast.SeqExpr {+          Ast.seqExprOp = (Ast.seqExprOp v0),+          Ast.seqExprElements = (Lists.map parenthesize (Ast.seqExprElements v0))})+        Ast.ExprOp v0 ->+          let op = Ast.opExprOp v0+              prec = Ast.unPrecedence (Ast.opPrecedence op)+              assoc = Ast.opAssociativity op+              lhs = Ast.opExprLhs v0+              rhs = Ast.opExprRhs v0+              lhs_ = parenthesize lhs+              rhs_ = parenthesize rhs+              lhs2 =+                      case lhs_ of+                        Ast.ExprOp v1 ->+                          let lop = Ast.opExprOp v1+                              lprec = Ast.unPrecedence (Ast.opPrecedence lop)+                              lassoc = Ast.opAssociativity lop+                              comparison = Equality.compare prec lprec+                          in case comparison of+                            Util.ComparisonLessThan -> lhs_+                            Util.ComparisonGreaterThan -> parens lhs_+                            Util.ComparisonEqualTo -> Logic.ifElse (Logic.and (assocLeft assoc) (assocLeft lassoc)) lhs_ (parens lhs_)+                        _ -> lhs_+              rhs2 =+                      case rhs_ of+                        Ast.ExprOp v1 ->+                          let rop = Ast.opExprOp v1+                              rprec = Ast.unPrecedence (Ast.opPrecedence rop)+                              rassoc = Ast.opAssociativity rop+                              comparison = Equality.compare prec rprec+                          in case comparison of+                            Util.ComparisonLessThan -> rhs_+                            Util.ComparisonGreaterThan -> parens rhs_+                            Util.ComparisonEqualTo -> Logic.ifElse (Logic.and (assocRight assoc) (assocRight rassoc)) rhs_ (parens rhs_)+                        _ -> rhs_+          in (Ast.ExprOp (Ast.OpExpr {+            Ast.opExprOp = op,+            Ast.opExprLhs = lhs2,+            Ast.opExprRhs = rhs2}))+-- | Prepend a prefix string to an expression with no surrounding whitespace+prefix :: String -> Ast.Expr -> Ast.Expr+prefix p expr =++      let preOp =+              Ast.Op {+                Ast.opSymbol = (sym p),+                Ast.opPadding = Ast.Padding {+                  Ast.paddingLeft = Ast.WsNone,+                  Ast.paddingRight = Ast.WsNone},+                Ast.opPrecedence = (Ast.Precedence 0),+                Ast.opAssociativity = Ast.AssociativityNone}+      in (ifx preOp (cst "") expr)+-- | Render an expression to a string, expanding bracket pairs, block styles, indents, and operator chains+printExpr :: Ast.Expr -> String+printExpr e =++      let pad =+              \ws -> case ws of+                Ast.WsNone -> ""+                Ast.WsSpace -> " "+                Ast.WsBreak -> "\n"+                Ast.WsBreakAndIndent _ -> "\n"+                Ast.WsDoubleBreak -> "\n\n"+          idt =+                  \ws -> \s -> case ws of+                    Ast.WsBreakAndIndent v0 -> customIndent v0 s+                    _ -> s+      in case e of+        Ast.ExprConst v0 -> Ast.unSymbol v0+        Ast.ExprIndent v0 ->+          let style = Ast.indentedExpressionStyle v0+              expr = Ast.indentedExpressionExpr v0+              lns = Strings.lines (printExpr expr)+              indentLine = \pre -> \line -> Logic.ifElse (Equality.equal line "") line (Strings.cat2 pre line)+              ilns =+                      case style of+                        Ast.IndentStyleAllLines v1 -> Lists.map (indentLine v1) lns+                        Ast.IndentStyleSubsequentLines v1 -> Logic.ifElse (Equality.equal (Lists.length lns) 1) lns (Optionals.fromOptional lns (Optionals.map (\uc -> Lists.cons (Pairs.first uc) (Lists.map (indentLine v1) (Pairs.second uc))) (Lists.uncons lns)))+          in (Strings.intercalate "\n" ilns)+        Ast.ExprSeq v0 ->+          let sop = Ast.seqExprOp v0+              ssym = Ast.unSymbol (Ast.opSymbol sop)+              spadding = Ast.opPadding sop+              spadl = Ast.paddingLeft spadding+              spadr = Ast.paddingRight spadding+              selements = Ast.seqExprElements v0+              printedElements = Lists.map (\el -> idt spadr (printExpr el)) selements+              isNewlineWs =+                      \ws -> case ws of+                        Ast.WsBreak -> True+                        Ast.WsBreakAndIndent _ -> True+                        Ast.WsDoubleBreak -> True+                        _ -> False+              spadlIsNewline = isNewlineWs spadl+              spadrIsNewline = isNewlineWs spadr+              joinElements =+                      \acc -> \el ->+                        let elStartsWithNewline = Optionals.cases (Strings.maybeCharAt 0 el) False (\c -> Equality.equal c 10)+                            elIsEmpty = Equality.equal el ""+                            padlEff =+                                    Logic.ifElse (Logic.or (Logic.and elStartsWithNewline (Logic.not spadlIsNewline)) (Logic.and elIsEmpty (Equality.equal ssym ""))) "" (pad spadl)+                            padrEff =+                                    Logic.ifElse (Logic.or (Logic.and elStartsWithNewline (Logic.not spadrIsNewline)) (Logic.and elIsEmpty (Equality.equal ssym ""))) "" (pad spadr)+                        in (Strings.cat [+                          acc,+                          padlEff,+                          ssym,+                          padrEff,+                          el])+          in (Optionals.cases (Lists.maybeHead printedElements) "" (\h -> Lists.foldl joinElements h (Lists.drop 1 printedElements)))+        Ast.ExprOp v0 ->+          let op = Ast.opExprOp v0+              sym = Ast.unSymbol (Ast.opSymbol op)+              padding = Ast.opPadding op+              padl = Ast.paddingLeft padding+              padr = Ast.paddingRight padding+              l = Ast.opExprLhs v0+              r = Ast.opExprRhs v0+              lhs = idt padl (printExpr l)+              rhs = idt padr (printExpr r)+              padrIsNewline =+                      case padr of+                        Ast.WsBreak -> True+                        Ast.WsBreakAndIndent _ -> True+                        Ast.WsDoubleBreak -> True+                        _ -> False+              padlEffective = Logic.ifElse (Logic.and (Equality.equal sym "") (Logic.or padrIsNewline (Equality.equal rhs ""))) "" (pad padl)+              padrPad = pad padr+              rhsStartsWithNewline = Optionals.cases (Strings.maybeCharAt 0 rhs) False (\c -> Equality.equal c 10)+              padrEffective = Logic.ifElse (Logic.and rhsStartsWithNewline (Logic.not padrIsNewline)) "" padrPad+          in (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 lhs padlEffective) sym) padrEffective) rhs)+        Ast.ExprBrackets v0 ->+          let brs = Ast.bracketExprBrackets v0+              l = Ast.unSymbol (Ast.bracketsOpen brs)+              r = Ast.unSymbol (Ast.bracketsClose brs)+              e = Ast.bracketExprEnclosed v0+              style = Ast.bracketExprStyle v0+              body = printExpr e+              doIndent = Ast.blockStyleIndent style+              nlBefore = Ast.blockStyleNewlineBeforeContent style+              nlAfter = Ast.blockStyleNewlineAfterContent style+              ibody = Optionals.cases doIndent body (\pre -> customIndent pre body)+              pre = Logic.ifElse nlBefore "\n" ""+              suf = Logic.ifElse nlAfter "\n" ""+          in (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 l pre) ibody) suf) r)+-- | Separate elements with `;` inline+semicolonSep :: [Ast.Expr] -> Ast.Expr+semicolonSep = symbolSep ";" inlineStyle+-- | Combine a list of expressions into a single OpExpr chain using the given operator. Returns the empty constant for an empty list.+sep :: Ast.Op -> [Ast.Expr] -> Ast.Expr+sep op els =+    Optionals.cases (Lists.maybeHead els) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx op acc el) h (Lists.drop 1 els))+-- | Space-separate elements (no break between them)+spaceSep :: [Ast.Expr] -> Ast.Expr+spaceSep =+    sep (Ast.Op {+      Ast.opSymbol = (sym ""),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsSpace,+        Ast.paddingRight = Ast.WsNone},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone})+-- | Space-separate elements inline if the joined width fits, otherwise newline-separate them. Useful for long signatures, type chains, and other space-joined sequences.+spaceSepAdaptive :: [Ast.Expr] -> Ast.Expr+spaceSepAdaptive els = chooseLayout maxLineWidth (spaceSep els) (newlineSep els)+-- | Square bracket pair `[` `]` for use with `brackets`+squareBrackets :: Ast.Brackets+squareBrackets =+    Ast.Brackets {+      Ast.bracketsOpen = (Ast.Symbol "["),+      Ast.bracketsClose = (Ast.Symbol "]")}+-- | Like sep, but produces a SeqExpr instead of an OpExpr chain. SeqExpr is treated as structural layout and is not subject to parenthesization.+structuralSep :: Ast.Op -> [Ast.Expr] -> Ast.Expr+structuralSep op els =+    Logic.ifElse (Lists.null els) (cst "") (Logic.ifElse (Equality.equal (Lists.length els) 1) (Optionals.fromOptional (cst "") (Lists.maybeHead els)) (Ast.ExprSeq (Ast.SeqExpr {+      Ast.seqExprOp = op,+      Ast.seqExprElements = els})))+-- | Like spaceSep, but produces a SeqExpr. Use for structural layout that should not trigger parenthesization of children.+structuralSpaceSep :: [Ast.Expr] -> Ast.Expr+structuralSpaceSep =+    structuralSep (Ast.Op {+      Ast.opSymbol = (sym ""),+      Ast.opPadding = Ast.Padding {+        Ast.paddingLeft = Ast.WsSpace,+        Ast.paddingRight = Ast.WsNone},+      Ast.opPrecedence = (Ast.Precedence 0),+      Ast.opAssociativity = Ast.AssociativityNone})+-- | Append a suffix string to an expression+suffix :: String -> Ast.Expr -> Ast.Expr+suffix s expr =++      let sufOp =+              Ast.Op {+                Ast.opSymbol = (sym s),+                Ast.opPadding = Ast.Padding {+                  Ast.paddingLeft = Ast.WsNone,+                  Ast.paddingRight = Ast.WsNone},+                Ast.opPrecedence = (Ast.Precedence 0),+                Ast.opAssociativity = Ast.AssociativityNone}+      in (ifx sufOp expr (cst ""))+-- | Construct a Symbol from a string+sym :: String -> Ast.Symbol+sym s = Ast.Symbol s+-- | Separate elements with the given symbol; trailing whitespace per element is determined by the block style's newline-before/after flags (space, single break, or double break)+symbolSep :: String -> Ast.BlockStyle -> [Ast.Expr] -> Ast.Expr+symbolSep symb style l =++      let breakCount =+              Lists.length (Lists.filter (\x_ -> x_) [+                Ast.blockStyleNewlineBeforeContent style,+                (Ast.blockStyleNewlineAfterContent style)])+          break =+                  Logic.ifElse (Equality.equal breakCount 0) Ast.WsSpace (Logic.ifElse (Equality.equal breakCount 1) Ast.WsBreak Ast.WsDoubleBreak)+          commaOp =+                  Ast.Op {+                    Ast.opSymbol = (sym symb),+                    Ast.opPadding = Ast.Padding {+                      Ast.paddingLeft = Ast.WsNone,+                      Ast.paddingRight = break},+                    Ast.opPrecedence = (Ast.Precedence 0),+                    Ast.opAssociativity = Ast.AssociativityNone}+      in (Optionals.cases (Lists.maybeHead l) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx commaOp acc el) h (Lists.drop 1 l)))+-- | Indent every line of an expression by four spaces+tabIndent :: Ast.Expr -> Ast.Expr+tabIndent e =+    Ast.ExprIndent (Ast.IndentedExpression {+      Ast.indentedExpressionStyle = (Ast.IndentStyleAllLines "    "),+      Ast.indentedExpressionExpr = e})+-- | Tab-indent a list of expressions, separated by blank lines+tabIndentDoubleSpace :: [Ast.Expr] -> Ast.Expr+tabIndentDoubleSpace exprs = tabIndent (doubleNewlineSep exprs)+-- | Tab-indent a list of expressions, separated by single newlines+tabIndentSingleSpace :: [Ast.Expr] -> Ast.Expr+tabIndentSingleSpace exprs = tabIndent (newlineSep exprs)+-- | Render a placeholder for a type the writer does not yet handle, e.g. `[bigint]`+unsupportedType :: String -> Ast.Expr+unsupportedType label = cst (Strings.cat2 (Strings.cat2 "[" label) "]")+-- | Render a placeholder for an unsupported variant, including a string representation of the offending value+unsupportedVariant :: String -> String -> Ast.Expr+unsupportedVariant label obj =+    cst (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "[unsupported " label) ": ") (Literals.showString obj)) "]")+-- | Append a trailing comma to an expression+withComma :: Ast.Expr -> Ast.Expr+withComma e =+    noSep [+      e,+      (cst ",")]+-- | Append a trailing semicolon to an expression+withSemi :: Ast.Expr -> Ast.Expr+withSemi e =+    noSep [+      e,+      (cst ";")]
+ src/main/haskell/Hydra/Settings.hs view
@@ -0,0 +1,5 @@+-- | The one non-generated Hydra kernel module. It contains constants which are set individually in each Hydra implementation.++module Hydra.Settings where++hydraDebug = True :: Bool
+ src/main/haskell/Hydra/Show/Core.hs view
@@ -0,0 +1,498 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.core types++module Hydra.Show.Core where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Eithers as Eithers+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.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Show a binding as a string+binding :: Core.Binding -> String+binding el =++      let name = Core.unName (Core.bindingName el)+          t = Core.bindingTerm el+          typeStr =+                  Optionals.cases (Core.bindingTypeScheme el) "" (\ts -> Strings.cat [+                    ":(",+                    (typeScheme ts),+                    ")"])+      in (Strings.cat [+        name,+        typeStr,+        " = ",+        (term t)])+-- | Show a case statement as a string+caseStatement :: Core.CaseStatement -> String+caseStatement cs =++      let tname = Core.unName (Core.caseStatementTypeName cs)+          mdef = Core.caseStatementDefault cs+          csCases = Core.caseStatementCases cs+          caseFields =+                  Lists.map (\alt -> Core.Field {+                    Core.fieldName = (Core.caseAlternativeName alt),+                    Core.fieldTerm = (Core.caseAlternativeHandler alt)}) csCases+          defaultField =+                  Optionals.cases mdef [] (\d -> [+                    Core.Field {+                      Core.fieldName = (Core.Name "[default]"),+                      Core.fieldTerm = d}])+          allFields =+                  Lists.concat [+                    caseFields,+                    defaultField]+      in (Strings.cat [+        "case(",+        tname,+        ")",+        (fields allFields)])+-- | Show an Either value using given functions for left and right+either :: (t0 -> String) -> (t1 -> String) -> Either t0 t1 -> String+either showA showB e =+    Eithers.either (\a -> Strings.cat2 "left(" (Strings.cat2 (showA a) ")")) (\b -> Strings.cat2 "right(" (Strings.cat2 (showB b) ")")) e+-- | Show a field as a string+field :: Core.Field -> String+field field =++      let fname = Core.unName (Core.fieldName field)+          fterm = Core.fieldTerm field+      in (Strings.cat [+        fname,+        "=",+        (term fterm)])+-- | Show a field type as a string+fieldType :: Core.FieldType -> String+fieldType ft =++      let fname = Core.unName (Core.fieldTypeName ft)+          ftyp = Core.fieldTypeType ft+      in (Strings.cat [+        fname,+        ":",+        (type_ ftyp)])+-- | Show a list of fields as a string+fields :: [Core.Field] -> String+fields flds =++      let fieldStrs = Lists.map field flds+      in (Strings.cat [+        "{",+        (Strings.intercalate ", " fieldStrs),+        "}"])+-- | Show a float value as a string+float :: Core.FloatValue -> String+float fv =+    case fv of+      Core.FloatValueFloat32 v0 -> Strings.cat2 (Literals.showFloat32 v0) ":float32"+      Core.FloatValueFloat64 v0 -> Strings.cat2 (Literals.showFloat64 v0) ":float64"+-- | Show a float type as a string+floatType :: Core.FloatType -> String+floatType ft =+    case ft of+      Core.FloatTypeFloat32 -> "float32"+      Core.FloatTypeFloat64 -> "float64"+-- | Show an injection as a string+injection :: Core.Injection -> String+injection inj =++      let tname = Core.injectionTypeName inj+          f = Core.injectionField inj+      in (Strings.cat [+        "inject(",+        (Core.unName tname),+        ")",+        (fields [+          f])])+-- | Show an integer value as a string+integer :: Core.IntegerValue -> String+integer iv =+    case iv of+      Core.IntegerValueBigint v0 -> Strings.cat2 (Literals.showBigint v0) ":bigint"+      Core.IntegerValueInt8 v0 -> Strings.cat2 (Literals.showInt8 v0) ":int8"+      Core.IntegerValueInt16 v0 -> Strings.cat2 (Literals.showInt16 v0) ":int16"+      Core.IntegerValueInt32 v0 -> Strings.cat2 (Literals.showInt32 v0) ":int32"+      Core.IntegerValueInt64 v0 -> Strings.cat2 (Literals.showInt64 v0) ":int64"+      Core.IntegerValueUint8 v0 -> Strings.cat2 (Literals.showUint8 v0) ":uint8"+      Core.IntegerValueUint16 v0 -> Strings.cat2 (Literals.showUint16 v0) ":uint16"+      Core.IntegerValueUint32 v0 -> Strings.cat2 (Literals.showUint32 v0) ":uint32"+      Core.IntegerValueUint64 v0 -> Strings.cat2 (Literals.showUint64 v0) ":uint64"+-- | Show an integer type as a string+integerType :: Core.IntegerType -> String+integerType it =+    case it of+      Core.IntegerTypeBigint -> "bigint"+      Core.IntegerTypeInt8 -> "int8"+      Core.IntegerTypeInt16 -> "int16"+      Core.IntegerTypeInt32 -> "int32"+      Core.IntegerTypeInt64 -> "int64"+      Core.IntegerTypeUint8 -> "uint8"+      Core.IntegerTypeUint16 -> "uint16"+      Core.IntegerTypeUint32 -> "uint32"+      Core.IntegerTypeUint64 -> "uint64"+-- | Show a lambda as a string+lambda :: Core.Lambda -> String+lambda l =++      let v = Core.unName (Core.lambdaParameter l)+          mt = Core.lambdaDomain l+          body = Core.lambdaBody l+          typeStr = Optionals.cases mt "" (\t -> Strings.cat2 ":" (type_ t))+      in (Strings.cat [+        "\955",+        v,+        typeStr,+        ".",+        (term body)])+-- | Show a let expression as a string+let_ :: Core.Let -> String+let_ l =++      let bindings = Core.letBindings l+          env = Core.letBody l+          bindingStrs = Lists.map binding bindings+      in (Strings.cat [+        "let ",+        (Strings.intercalate ", " bindingStrs),+        " in ",+        (term env)])+-- | Show a list using a given function to show each element+list :: (t0 -> String) -> [t0] -> String+list f xs =++      let elementStrs = Lists.map f xs+      in (Strings.cat [+        "[",+        (Strings.intercalate ", " elementStrs),+        "]"])+-- | Show a literal as a string+literal :: Core.Literal -> String+literal l =+    case l of+      Core.LiteralBinary _ -> "[binary]"+      Core.LiteralBoolean v0 -> Logic.ifElse v0 "true" "false"+      Core.LiteralDecimal v0 -> Literals.showDecimal v0+      Core.LiteralFloat v0 -> float v0+      Core.LiteralInteger v0 -> integer v0+      Core.LiteralString v0 -> Literals.showString v0+-- | Show a literal type as a string+literalType :: Core.LiteralType -> String+literalType lt =+    case lt of+      Core.LiteralTypeBinary -> "binary"+      Core.LiteralTypeBoolean -> "boolean"+      Core.LiteralTypeDecimal -> "decimal"+      Core.LiteralTypeFloat v0 -> floatType v0+      Core.LiteralTypeInteger v0 -> integerType v0+      Core.LiteralTypeString -> "string"+-- | Show a map using given functions to show keys and values+map :: Ord t0 => ((t0 -> String) -> (t1 -> String) -> M.Map t0 t1 -> String)+map showK showV m =++      let pairStrs =+              Lists.map (\p -> Strings.cat [+                showK (Pairs.first p),+                ": ",+                (showV (Pairs.second p))]) (Maps.toList m)+      in (Strings.cat [+        "{",+        (Strings.intercalate ", " pairStrs),+        "}"])+-- | Show an optional value using a given function to show the element+optional :: (t0 -> String) -> Maybe t0 -> String+optional f mx = Optionals.cases mx "none" (\x -> Strings.cat2 "given(" (Strings.cat2 (f x) ")"))+-- | Show a pair using given functions to show each element+pair :: (t0 -> String) -> (t1 -> String) -> (t0, t1) -> String+pair showA showB p =+    Strings.cat [+      "(",+      (showA (Pairs.first p)),+      ", ",+      (showB (Pairs.second p)),+      ")"]+-- | Show a projection as a string+projection :: Core.Projection -> String+projection proj =++      let tname = Core.unName (Core.projectionTypeName proj)+          fname = Core.unName (Core.projectionFieldName proj)+      in (Strings.cat [+        "project(",+        tname,+        "){",+        fname,+        "}"])+-- | A placeholder for reading terms from their serialized form. Not implemented.+readTerm :: String -> Maybe Core.Term+readTerm s = Just (Core.TermLiteral (Core.LiteralString s))+-- | Show a set using a given function to show each element+set :: Ord t0 => ((t0 -> String) -> S.Set t0 -> String)+set f xs =++      let elementStrs = Lists.map f (Sets.toList xs)+      in (Strings.cat [+        "{",+        (Strings.intercalate ", " elementStrs),+        "}"])+-- | Show a term as a string+term :: Core.Term -> String+term t =++      let gatherTerms =+              \prev -> \app ->+                let lhs = Core.applicationFunction app+                    rhs = Core.applicationArgument app+                in case lhs of+                  Core.TermApplication v0 -> gatherTerms (Lists.cons rhs prev) v0+                  _ -> Lists.cons lhs (Lists.cons rhs prev)+      in case t of+        Core.TermAnnotated v0 -> term (Core.annotatedTermBody v0)+        Core.TermApplication v0 ->+          let terms = gatherTerms [] v0+              termStrs = Lists.map term terms+          in (Strings.cat [+            "(",+            (Strings.intercalate " @ " termStrs),+            ")"])+        Core.TermCases v0 -> caseStatement v0+        Core.TermEither v0 -> Eithers.either (\l -> Strings.cat [+          "left(",+          (term l),+          ")"]) (\r -> Strings.cat [+          "right(",+          (term r),+          ")"]) v0+        Core.TermLambda v0 -> lambda v0+        Core.TermLet v0 -> let_ v0+        Core.TermList v0 ->+          let termStrs = Lists.map term v0+          in (Strings.cat [+            "[",+            (Strings.intercalate ", " termStrs),+            "]"])+        Core.TermLiteral v0 -> literal v0+        Core.TermMap v0 ->+          let entry =+                  \p -> Strings.cat [+                    term (Pairs.first p),+                    "=",+                    (term (Pairs.second p))]+          in (Strings.cat [+            "{",+            (Strings.intercalate ", " (Lists.map entry (Maps.toList v0))),+            "}"])+        Core.TermOptional v0 -> Optionals.cases v0 "none" (\t2 -> Strings.cat [+          "given(",+          (term t2),+          ")"])+        Core.TermPair v0 -> Strings.cat [+          "(",+          (term (Pairs.first v0)),+          ", ",+          (term (Pairs.second v0)),+          ")"]+        Core.TermProject v0 -> projection v0+        Core.TermRecord v0 ->+          let tname = Core.unName (Core.recordTypeName v0)+              flds = Core.recordFields v0+          in (Strings.cat [+            "record(",+            tname,+            ")",+            (fields flds)])+        Core.TermSet v0 -> Strings.cat [+          "{",+          (Strings.intercalate ", " (Lists.map term (Sets.toList v0))),+          "}"]+        Core.TermTypeLambda v0 ->+          let param = Core.unName (Core.typeLambdaParameter v0)+              body = Core.typeLambdaBody v0+          in (Strings.cat [+            "\923",+            param,+            ".",+            (term body)])+        Core.TermTypeApplication v0 ->+          let t2 = Core.typeApplicationTermBody v0+              typ = Core.typeApplicationTermType v0+          in (Strings.cat [+            term t2,+            "\10216",+            (type_ typ),+            "\10217"])+        Core.TermInject v0 -> injection v0+        Core.TermUnit -> "unit"+        Core.TermUnwrap v0 -> Strings.cat [+          "unwrap(",+          (Core.unName v0),+          ")"]+        Core.TermVariable v0 -> Core.unName v0+        Core.TermWrap v0 ->+          let tname = Core.unName (Core.wrappedTermTypeName v0)+              term1 = Core.wrappedTermBody v0+          in (Strings.cat [+            "wrap(",+            tname,+            "){",+            (term term1),+            "}"])+-- | Show a type as a string+type_ :: Core.Type -> String+type_ typ =++      let showRowType =+              \flds ->+                let fieldStrs = Lists.map fieldType flds+                in (Strings.cat [+                  "{",+                  (Strings.intercalate ", " fieldStrs),+                  "}"])+          gatherTypes =+                  \prev -> \app ->+                    let lhs = Core.applicationTypeFunction app+                        rhs = Core.applicationTypeArgument app+                    in case lhs of+                      Core.TypeApplication v0 -> gatherTypes (Lists.cons rhs prev) v0+                      _ -> Lists.cons lhs (Lists.cons rhs prev)+          gatherFunctionTypes =+                  \prev -> \t -> case t of+                    Core.TypeFunction v0 ->+                      let dom = Core.functionTypeDomain v0+                          cod = Core.functionTypeCodomain v0+                      in (gatherFunctionTypes (Lists.cons dom prev) cod)+                    _ -> Lists.reverse (Lists.cons t prev)+      in case typ of+        Core.TypeAnnotated v0 -> type_ (Core.annotatedTypeBody v0)+        Core.TypeApplication v0 ->+          let types = gatherTypes [] v0+              typeStrs = Lists.map type_ types+          in (Strings.cat [+            "(",+            (Strings.intercalate " @ " typeStrs),+            ")"])+        Core.TypeEither v0 ->+          let leftTyp = Core.eitherTypeLeft v0+              rightTyp = Core.eitherTypeRight v0+          in (Strings.cat [+            "either<",+            (type_ leftTyp),+            ", ",+            (type_ rightTyp),+            ">"])+        Core.TypeForall v0 ->+          let var = Core.unName (Core.forallTypeParameter v0)+              body = Core.forallTypeBody v0+          in (Strings.cat [+            "(\8704",+            var,+            ".",+            (type_ body),+            ")"])+        Core.TypeFunction _ ->+          let types = gatherFunctionTypes [] typ+              typeStrs = Lists.map type_ types+          in (Strings.cat [+            "(",+            (Strings.intercalate " \8594 " typeStrs),+            ")"])+        Core.TypeList v0 -> Strings.cat [+          "list<",+          (type_ v0),+          ">"]+        Core.TypeLiteral v0 -> literalType v0+        Core.TypeMap v0 ->+          let keyTyp = Core.mapTypeKeys v0+              valTyp = Core.mapTypeValues v0+          in (Strings.cat [+            "map<",+            (type_ keyTyp),+            ", ",+            (type_ valTyp),+            ">"])+        Core.TypeOptional v0 -> Strings.cat [+          "optional<",+          (type_ v0),+          ">"]+        Core.TypePair v0 ->+          let firstTyp = Core.pairTypeFirst v0+              secondTyp = Core.pairTypeSecond v0+          in (Strings.cat [+            "(",+            (type_ firstTyp),+            ", ",+            (type_ secondTyp),+            ")"])+        Core.TypeRecord v0 -> Strings.cat2 "record" (showRowType v0)+        Core.TypeSet v0 -> Strings.cat [+          "set<",+          (type_ v0),+          ">"]+        Core.TypeUnion v0 -> Strings.cat2 "union" (showRowType v0)+        Core.TypeUnit -> "unit"+        Core.TypeVariable v0 -> Core.unName v0+        Core.TypeVoid -> "void"+        Core.TypeWrap v0 -> Strings.cat [+          "wrap(",+          (type_ v0),+          ")"]+-- | Show a type scheme as a string+typeScheme :: Core.TypeScheme -> String+typeScheme ts =++      let vars = Core.typeSchemeVariables ts+          body = Core.typeSchemeBody ts+          varNames = Lists.map Core.unName vars+          fa =+                  Logic.ifElse (Lists.null vars) "" (Strings.cat [+                    "forall ",+                    (Strings.intercalate "," varNames),+                    ". "])+          toConstraintPair =+                  \v -> \c -> Strings.cat [+                    case c of+                      Core.TypeClassConstraintSimple v0 -> Core.unName v0,+                    " ",+                    (Core.unName v)]+          toConstraintPairs =+                  \p -> Lists.map (toConstraintPair (Pairs.first p)) (Core.typeVariableConstraintsClasses (Pairs.second p))+          tc = Optionals.cases (Core.typeSchemeConstraints ts) [] (\m -> Lists.concat (Lists.map toConstraintPairs (Maps.toList m)))+      in (Strings.cat [+        "(",+        fa,+        (Logic.ifElse (Lists.null tc) "" (Strings.cat [+          "(",+          (Strings.intercalate ", " tc),+          ") => "])),+        (type_ body),+        ")"])
+ src/main/haskell/Hydra/Show/Error/Core.hs view
@@ -0,0 +1,296 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.error.core types++module Hydra.Show.Error.Core where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Literals as Literals+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Variants as ShowVariants+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Show a constant condition error as a string+constantConditionError :: ErrorCore.ConstantConditionError -> String+constantConditionError e =+    Strings.cat [+      "constant condition: ifElse with literal ",+      (Literals.showBoolean (ErrorCore.constantConditionErrorValue e))]+-- | Show a duplicate binding error as a string+duplicateBindingError :: ErrorCore.DuplicateBindingError -> String+duplicateBindingError e =+    Strings.cat [+      "duplicate binding: ",+      (Core.unName (ErrorCore.duplicateBindingErrorName e))]+-- | Show a duplicate field error as a string+duplicateFieldError :: ErrorCore.DuplicateFieldError -> String+duplicateFieldError e =+    Strings.cat [+      "duplicate field: ",+      (Core.unName (ErrorCore.duplicateFieldErrorName e))]+-- | Show a duplicate record type field names error as a string+duplicateRecordTypeFieldNamesError :: ErrorCore.DuplicateRecordTypeFieldNamesError -> String+duplicateRecordTypeFieldNamesError e =+    Strings.cat [+      "duplicate field in record type: ",+      (Core.unName (ErrorCore.duplicateRecordTypeFieldNamesErrorName e))]+-- | Show a duplicate union type field names error as a string+duplicateUnionTypeFieldNamesError :: ErrorCore.DuplicateUnionTypeFieldNamesError -> String+duplicateUnionTypeFieldNamesError e =+    Strings.cat [+      "duplicate field in union type: ",+      (Core.unName (ErrorCore.duplicateUnionTypeFieldNamesErrorName e))]+-- | Show an empty case statement error as a string+emptyCaseStatementError :: ErrorCore.EmptyCaseStatementError -> String+emptyCaseStatementError e =+    Strings.cat [+      "empty case statement for type: ",+      (Core.unName (ErrorCore.emptyCaseStatementErrorTypeName e))]+-- | Show an empty let bindings error as a string+emptyLetBindingsError :: t0 -> String+emptyLetBindingsError e = "let expression with no bindings"+-- | Show an empty record type error as a string+emptyRecordTypeError :: t0 -> String+emptyRecordTypeError e = "record type with no fields (use TypeUnit instead)"+-- | Show an empty term annotation error as a string+emptyTermAnnotationError :: t0 -> String+emptyTermAnnotationError e = "term annotation with empty annotation map"+-- | Show an empty type annotation error as a string+emptyTypeAnnotationError :: t0 -> String+emptyTypeAnnotationError e = "type annotation with empty annotation map"+-- | Show an empty type name in term error as a string+emptyTypeNameInTermError :: t0 -> String+emptyTypeNameInTermError e = "term with empty type name"+-- | Show an empty union type error as a string+emptyUnionTypeError :: t0 -> String+emptyUnionTypeError e = "union type with no alternatives (use TypeVoid instead)"+-- | Show an invalid forall parameter name error as a string+invalidForallParameterNameError :: ErrorCore.InvalidForallParameterNameError -> String+invalidForallParameterNameError e =+    Strings.cat [+      "invalid forall parameter name: ",+      (Core.unName (ErrorCore.invalidForallParameterNameErrorName e))]+-- | Show an invalid lambda parameter name error as a string+invalidLambdaParameterNameError :: ErrorCore.InvalidLambdaParameterNameError -> String+invalidLambdaParameterNameError e =+    Strings.cat [+      "invalid lambda parameter name: ",+      (Core.unName (ErrorCore.invalidLambdaParameterNameErrorName e))]+-- | Show an invalid let binding name error as a string+invalidLetBindingNameError :: ErrorCore.InvalidLetBindingNameError -> String+invalidLetBindingNameError e =+    Strings.cat [+      "invalid let binding name: ",+      (Core.unName (ErrorCore.invalidLetBindingNameErrorName e))]+-- | Show an invalid term error as a string+invalidTermError :: ErrorCore.InvalidTermError -> String+invalidTermError e =+    Strings.cat2 "invalid term: " (case e of+      ErrorCore.InvalidTermErrorConstantCondition v0 -> constantConditionError v0+      ErrorCore.InvalidTermErrorDuplicateBinding v0 -> duplicateBindingError v0+      ErrorCore.InvalidTermErrorDuplicateField v0 -> duplicateFieldError v0+      ErrorCore.InvalidTermErrorEmptyCaseStatement v0 -> emptyCaseStatementError v0+      ErrorCore.InvalidTermErrorEmptyLetBindings v0 -> emptyLetBindingsError v0+      ErrorCore.InvalidTermErrorEmptyTermAnnotation v0 -> emptyTermAnnotationError v0+      ErrorCore.InvalidTermErrorEmptyTypeNameInTerm v0 -> emptyTypeNameInTermError v0+      ErrorCore.InvalidTermErrorInvalidLambdaParameterName v0 -> invalidLambdaParameterNameError v0+      ErrorCore.InvalidTermErrorInvalidLetBindingName v0 -> invalidLetBindingNameError v0+      ErrorCore.InvalidTermErrorInvalidTypeLambdaParameterName v0 -> invalidTypeLambdaParameterNameError v0+      ErrorCore.InvalidTermErrorNestedTermAnnotation v0 -> nestedTermAnnotationError v0+      ErrorCore.InvalidTermErrorRedundantWrapUnwrap v0 -> redundantWrapUnwrapError v0+      ErrorCore.InvalidTermErrorSelfApplication v0 -> selfApplicationError v0+      ErrorCore.InvalidTermErrorTermVariableShadowing v0 -> termVariableShadowingError v0+      ErrorCore.InvalidTermErrorTypeVariableShadowingInTypeLambda v0 -> typeVariableShadowingInTypeLambdaError v0+      ErrorCore.InvalidTermErrorUndefinedTermVariable v0 -> undefinedTermVariableError v0+      ErrorCore.InvalidTermErrorUndefinedTypeVariableInBindingType v0 -> undefinedTypeVariableInBindingTypeError v0+      ErrorCore.InvalidTermErrorUndefinedTypeVariableInLambdaDomain v0 -> undefinedTypeVariableInLambdaDomainError v0+      ErrorCore.InvalidTermErrorUndefinedTypeVariableInTypeApplication v0 -> undefinedTypeVariableInTypeApplicationError v0+      ErrorCore.InvalidTermErrorUnknownPrimitiveName v0 -> unknownPrimitiveNameError v0+      ErrorCore.InvalidTermErrorUnnecessaryIdentityApplication v0 -> unnecessaryIdentityApplicationError v0+      ErrorCore.InvalidTermErrorUntypedTermVariable v0 -> untypedTermVariableError v0)+-- | Show an invalid type error as a string+invalidTypeError :: ErrorCore.InvalidTypeError -> String+invalidTypeError e =+    Strings.cat2 "invalid type: " (case e of+      ErrorCore.InvalidTypeErrorDuplicateRecordTypeFieldNames v0 -> duplicateRecordTypeFieldNamesError v0+      ErrorCore.InvalidTypeErrorDuplicateUnionTypeFieldNames v0 -> duplicateUnionTypeFieldNamesError v0+      ErrorCore.InvalidTypeErrorEmptyRecordType v0 -> emptyRecordTypeError v0+      ErrorCore.InvalidTypeErrorEmptyTypeAnnotation v0 -> emptyTypeAnnotationError v0+      ErrorCore.InvalidTypeErrorEmptyUnionType v0 -> emptyUnionTypeError v0+      ErrorCore.InvalidTypeErrorInvalidForallParameterName v0 -> invalidForallParameterNameError v0+      ErrorCore.InvalidTypeErrorInvalidTypeSchemeVariableName v0 -> invalidTypeSchemeVariableNameError v0+      ErrorCore.InvalidTypeErrorNestedTypeAnnotation v0 -> nestedTypeAnnotationError v0+      ErrorCore.InvalidTypeErrorNonComparableMapKeyType v0 -> nonComparableMapKeyTypeError v0+      ErrorCore.InvalidTypeErrorNonComparableSetElementType v0 -> nonComparableSetElementTypeError v0+      ErrorCore.InvalidTypeErrorSingleVariantUnion v0 -> singleVariantUnionError v0+      ErrorCore.InvalidTypeErrorTypeVariableShadowingInForall v0 -> typeVariableShadowingInForallError v0+      ErrorCore.InvalidTypeErrorUndefinedTypeVariable v0 -> undefinedTypeVariableError v0+      ErrorCore.InvalidTypeErrorVoidInNonBottomPosition v0 -> voidInNonBottomPositionError v0)+-- | Show an invalid type lambda parameter name error as a string+invalidTypeLambdaParameterNameError :: ErrorCore.InvalidTypeLambdaParameterNameError -> String+invalidTypeLambdaParameterNameError e =+    Strings.cat [+      "invalid type lambda parameter name: ",+      (Core.unName (ErrorCore.invalidTypeLambdaParameterNameErrorName e))]+-- | Show an invalid type scheme variable name error as a string+invalidTypeSchemeVariableNameError :: ErrorCore.InvalidTypeSchemeVariableNameError -> String+invalidTypeSchemeVariableNameError e =+    Strings.cat [+      "invalid type scheme variable name: ",+      (Core.unName (ErrorCore.invalidTypeSchemeVariableNameErrorName e))]+-- | Show a nested term annotation error as a string+nestedTermAnnotationError :: t0 -> String+nestedTermAnnotationError e = "nested term annotations should be merged"+-- | Show a nested type annotation error as a string+nestedTypeAnnotationError :: t0 -> String+nestedTypeAnnotationError e = "nested type annotations should be merged"+-- | Show a non-comparable map key type error as a string+nonComparableMapKeyTypeError :: ErrorCore.NonComparableMapKeyTypeError -> String+nonComparableMapKeyTypeError e =+    Strings.cat [+      "map key type contains a function type: ",+      (ShowCore.type_ (ErrorCore.nonComparableMapKeyTypeErrorKeyType e))]+-- | Show a non-comparable set element type error as a string+nonComparableSetElementTypeError :: ErrorCore.NonComparableSetElementTypeError -> String+nonComparableSetElementTypeError e =+    Strings.cat [+      "set element type contains a function type: ",+      (ShowCore.type_ (ErrorCore.nonComparableSetElementTypeErrorElementType e))]+-- | Show a redundant wrap/unwrap error as a string+redundantWrapUnwrapError :: ErrorCore.RedundantWrapUnwrapError -> String+redundantWrapUnwrapError e =+    Strings.cat [+      "redundant wrap/unwrap for type: ",+      (Core.unName (ErrorCore.redundantWrapUnwrapErrorTypeName e))]+-- | Show a self-application error as a string+selfApplicationError :: ErrorCore.SelfApplicationError -> String+selfApplicationError e =+    Strings.cat [+      "self-application of variable: ",+      (Core.unName (ErrorCore.selfApplicationErrorName e))]+-- | Show a single variant union error as a string+singleVariantUnionError :: ErrorCore.SingleVariantUnionError -> String+singleVariantUnionError e =+    Strings.cat [+      "union type with single variant: ",+      (Core.unName (ErrorCore.singleVariantUnionErrorFieldName e))]+-- | Show a term variable shadowing error as a string+termVariableShadowingError :: ErrorCore.TermVariableShadowingError -> String+termVariableShadowingError e =+    Strings.cat [+      "variable shadowing: ",+      (Core.unName (ErrorCore.termVariableShadowingErrorName e))]+-- | Show a type variable shadowing in forall error as a string+typeVariableShadowingInForallError :: ErrorCore.TypeVariableShadowingInForallError -> String+typeVariableShadowingInForallError e =+    Strings.cat [+      "type variable shadowing in forall: ",+      (Core.unName (ErrorCore.typeVariableShadowingInForallErrorName e))]+-- | Show a type variable shadowing in type lambda error as a string+typeVariableShadowingInTypeLambdaError :: ErrorCore.TypeVariableShadowingInTypeLambdaError -> String+typeVariableShadowingInTypeLambdaError e =+    Strings.cat [+      "type variable shadowing in type lambda: ",+      (Core.unName (ErrorCore.typeVariableShadowingInTypeLambdaErrorName e))]+-- | Show an undefined field error as a string+undefinedFieldError :: ErrorCore.UndefinedFieldError -> String+undefinedFieldError e =++      let fname = ErrorCore.undefinedFieldErrorFieldName e+          tname = ErrorCore.undefinedFieldErrorTypeName e+      in (Strings.cat [+        "no such field \"",+        (Core.unName fname),+        "\" in type \"",+        (Core.unName tname),+        "\""])+-- | Show an undefined term variable error as a string+undefinedTermVariableError :: ErrorCore.UndefinedTermVariableError -> String+undefinedTermVariableError e =+    Strings.cat [+      "undefined term variable: ",+      (Core.unName (ErrorCore.undefinedTermVariableErrorName e))]+-- | Show an undefined type variable error as a string+undefinedTypeVariableError :: ErrorCore.UndefinedTypeVariableError -> String+undefinedTypeVariableError e =+    Strings.cat [+      "undefined type variable: ",+      (Core.unName (ErrorCore.undefinedTypeVariableErrorName e))]+-- | Show an undefined type variable in binding type error as a string+undefinedTypeVariableInBindingTypeError :: ErrorCore.UndefinedTypeVariableInBindingTypeError -> String+undefinedTypeVariableInBindingTypeError e =+    Strings.cat [+      "undefined type variable in binding type: ",+      (Core.unName (ErrorCore.undefinedTypeVariableInBindingTypeErrorName e))]+-- | Show an undefined type variable in lambda domain error as a string+undefinedTypeVariableInLambdaDomainError :: ErrorCore.UndefinedTypeVariableInLambdaDomainError -> String+undefinedTypeVariableInLambdaDomainError e =+    Strings.cat [+      "undefined type variable in lambda domain: ",+      (Core.unName (ErrorCore.undefinedTypeVariableInLambdaDomainErrorName e))]+-- | Show an undefined type variable in type application error as a string+undefinedTypeVariableInTypeApplicationError :: ErrorCore.UndefinedTypeVariableInTypeApplicationError -> String+undefinedTypeVariableInTypeApplicationError e =+    Strings.cat [+      "undefined type variable in type application: ",+      (Core.unName (ErrorCore.undefinedTypeVariableInTypeApplicationErrorName e))]+-- | Show an unexpected term variant error as a string+unexpectedTermVariantError :: ErrorCore.UnexpectedTermVariantError -> String+unexpectedTermVariantError e =++      let expected = ErrorCore.unexpectedTermVariantErrorExpectedVariant e+          actual = ErrorCore.unexpectedTermVariantErrorActualTerm e+      in (Strings.cat [+        "expected ",+        (ShowVariants.termVariant expected),+        " term but found ",+        (ShowCore.term actual)])+-- | Show an unexpected type variant error as a string+unexpectedTypeVariantError :: ErrorCore.UnexpectedTypeVariantError -> String+unexpectedTypeVariantError e =++      let expected = ErrorCore.unexpectedTypeVariantErrorExpectedVariant e+          actual = ErrorCore.unexpectedTypeVariantErrorActualType e+      in (Strings.cat [+        "expected ",+        (ShowVariants.typeVariant expected),+        " type but found ",+        (ShowCore.type_ actual)])+-- | Show an unknown primitive name error as a string+unknownPrimitiveNameError :: ErrorCore.UnknownPrimitiveNameError -> String+unknownPrimitiveNameError e =+    Strings.cat [+      "unknown primitive: ",+      (Core.unName (ErrorCore.unknownPrimitiveNameErrorName e))]+-- | Show an unnecessary identity application error as a string+unnecessaryIdentityApplicationError :: t0 -> String+unnecessaryIdentityApplicationError e = "unnecessary application of identity lambda"+-- | Show an untyped term variable error as a string+untypedTermVariableError :: ErrorCore.UntypedTermVariableError -> String+untypedTermVariableError e =+    Strings.cat [+      "untyped term variable: ",+      (Core.unName (ErrorCore.untypedTermVariableErrorName e))]+-- | Show a void in non-bottom position error as a string+voidInNonBottomPositionError :: t0 -> String+voidInNonBottomPositionError e = "TypeVoid in a position where no value can be constructed"
+ src/main/haskell/Hydra/Show/Error/Packaging.hs view
@@ -0,0 +1,135 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.error.packaging types++module Hydra.Show.Error.Packaging where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Util as ShowUtil+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Show a conflicting module namespace error as a string+conflictingModuleNameError :: ErrorPackaging.ConflictingModuleNameError -> String+conflictingModuleNameError e =+    Strings.cat [+      "module namespaces conflict when mapped to target language path: ",+      (Packaging.unModuleName (ErrorPackaging.conflictingModuleNameErrorFirst e)),+      " vs ",+      (Packaging.unModuleName (ErrorPackaging.conflictingModuleNameErrorSecond e))]+-- | Show a conflicting variant name error as a string+conflictingVariantNameError :: ErrorPackaging.ConflictingVariantNameError -> String+conflictingVariantNameError e =+    Strings.cat [+      "in module ",+      (Packaging.unModuleName (ErrorPackaging.conflictingVariantNameErrorModuleName e)),+      ": variant ",+      (Core.unName (ErrorPackaging.conflictingVariantNameErrorVariantName e)),+      " of type ",+      (Core.unName (ErrorPackaging.conflictingVariantNameErrorTypeName e)),+      " produces constructor name ",+      (Core.unName (ErrorPackaging.conflictingVariantNameErrorConflictingName e)),+      " which conflicts with another type definition"]+-- | Show a definition-not-in-module-namespace error as a string+definitionNotInModuleNameError :: ErrorPackaging.DefinitionNotInModuleNameError -> String+definitionNotInModuleNameError e =+    Strings.cat [+      "definition ",+      (Core.unName (ErrorPackaging.definitionNotInModuleNameErrorName e)),+      " is not in module namespace ",+      (Packaging.unModuleName (ErrorPackaging.definitionNotInModuleNameErrorModuleName e))]+-- | Show a definitions-out-of-order error as a string+definitionsOutOfOrderError :: ErrorPackaging.DefinitionsOutOfOrderError -> String+definitionsOutOfOrderError e =+    Strings.cat [+      "in module ",+      (Packaging.unModuleName (ErrorPackaging.definitionsOutOfOrderErrorModuleName e)),+      ": definitions out of order: ",+      (Core.unName (ErrorPackaging.definitionsOutOfOrderErrorPrecedingName e)),+      " precedes ",+      (Core.unName (ErrorPackaging.definitionsOutOfOrderErrorFollowingName e))]+-- | Show a duplicate definition name error as a string+duplicateDefinitionNameError :: ErrorPackaging.DuplicateDefinitionNameError -> String+duplicateDefinitionNameError e =+    Strings.cat [+      "in module ",+      (Packaging.unModuleName (ErrorPackaging.duplicateDefinitionNameErrorModuleName e)),+      ": duplicate definition name ",+      (Core.unName (ErrorPackaging.duplicateDefinitionNameErrorName e))]+-- | Show a duplicate module namespace error as a string+duplicateModuleNameError :: ErrorPackaging.DuplicateModuleNameError -> String+duplicateModuleNameError e =+    Strings.cat [+      "duplicate module namespace ",+      (Packaging.unModuleName (ErrorPackaging.duplicateModuleNameErrorModuleName e))]+-- | Show an invalid definition name error as a string+invalidDefinitionNameError :: ErrorPackaging.InvalidDefinitionNameError -> String+invalidDefinitionNameError e =+    Strings.cat [+      "in module ",+      (Packaging.unModuleName (ErrorPackaging.invalidDefinitionNameErrorModuleName e)),+      ": definition ",+      (Core.unName (ErrorPackaging.invalidDefinitionNameErrorName e)),+      " does not match expected ",+      (ShowUtil.caseConvention (ErrorPackaging.invalidDefinitionNameErrorExpectedConvention e))]+-- | Show an invalid module error as a string+invalidModuleError :: ErrorPackaging.InvalidModuleError -> String+invalidModuleError e =+    Strings.cat2 "invalid module: " (case e of+      ErrorPackaging.InvalidModuleErrorConflictingVariantName v0 -> conflictingVariantNameError v0+      ErrorPackaging.InvalidModuleErrorDefinitionNotInModuleName v0 -> definitionNotInModuleNameError v0+      ErrorPackaging.InvalidModuleErrorDefinitionsOutOfOrder v0 -> definitionsOutOfOrderError v0+      ErrorPackaging.InvalidModuleErrorDuplicateDefinitionName v0 -> duplicateDefinitionNameError v0+      ErrorPackaging.InvalidModuleErrorInvalidDefinitionName v0 -> invalidDefinitionNameError v0+      ErrorPackaging.InvalidModuleErrorInvalidModuleNameConvention v0 -> invalidModuleNameConventionError v0+      ErrorPackaging.InvalidModuleErrorMissingDocumentation v0 -> missingDocumentationError v0)+-- | Show an invalid namespace convention error as a string+invalidModuleNameConventionError :: ErrorPackaging.InvalidModuleNameConventionError -> String+invalidModuleNameConventionError e =+    Strings.cat [+      "namespace ",+      (Packaging.unModuleName (ErrorPackaging.invalidModuleNameConventionErrorModuleName e)),+      " does not match the dotted-camelCase naming convention"]+-- | Show an invalid package error as a string+invalidPackageError :: ErrorPackaging.InvalidPackageError -> String+invalidPackageError e =+    Strings.cat2 "invalid package: " (case e of+      ErrorPackaging.InvalidPackageErrorConflictingModuleName v0 -> conflictingModuleNameError v0+      ErrorPackaging.InvalidPackageErrorDuplicateModuleName v0 -> duplicateModuleNameError v0+      ErrorPackaging.InvalidPackageErrorInvalidModule v0 -> invalidModuleError v0+      ErrorPackaging.InvalidPackageErrorInvalidPackageName v0 -> invalidPackageNameError v0)+-- | Show an invalid package name error as a string+invalidPackageNameError :: ErrorPackaging.InvalidPackageNameError -> String+invalidPackageNameError e =+    Strings.cat [+      "package name ",+      (Packaging.unPackageName (ErrorPackaging.invalidPackageNameErrorPackageName e)),+      " does not match the hyphen-separated lowercase naming convention"]+-- | Show a missing documentation error as a string+missingDocumentationError :: ErrorPackaging.MissingDocumentationError -> String+missingDocumentationError e =+    Strings.cat [+      "in module ",+      (Packaging.unModuleName (ErrorPackaging.missingDocumentationErrorModuleName e)),+      ": definition ",+      (Core.unName (ErrorPackaging.missingDocumentationErrorName e)),+      " lacks a description annotation"]
+ src/main/haskell/Hydra/Show/Errors.hs view
@@ -0,0 +1,190 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.error types++module Hydra.Show.Errors where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Literals as Literals+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Show.Error.Core as ShowErrorCore+import qualified Hydra.Show.Typing as ShowTyping+import qualified Hydra.Show.Variants as ShowVariants+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Show a checking error as a string+checkingError :: Checking.CheckingError -> String+checkingError ce =+    case ce of+      Checking.CheckingErrorIncorrectUnification v0 -> incorrectUnificationError v0+      Checking.CheckingErrorNotAForallType v0 -> notAForallTypeError v0+      Checking.CheckingErrorNotAFunctionType v0 -> notAFunctionTypeError v0+      Checking.CheckingErrorTypeArityMismatch v0 -> typeArityMismatchError v0+      Checking.CheckingErrorTypeMismatch v0 -> typeMismatchError v0+      Checking.CheckingErrorUnboundTypeVariables v0 -> unboundTypeVariablesError v0+      Checking.CheckingErrorUnequalTypes v0 -> unequalTypesError v0+      Checking.CheckingErrorUnsupportedTermVariant v0 -> unsupportedTermVariantError v0+      Checking.CheckingErrorUntypedLambda v0 -> untypedLambdaError v0+      Checking.CheckingErrorUntypedLetBinding v0 -> untypedLetBindingError v0+-- | Show a decoding error as a string+decodingError :: Errors.DecodingError -> String+decodingError de = Strings.cat2 "decoding error: " (Errors.unDecodingError de)+-- | Show an error as a string+error :: Errors.Error -> String+error e =+    case e of+      Errors.ErrorChecking v0 -> checkingError v0+      Errors.ErrorDecoding v0 -> decodingError v0+      Errors.ErrorDuplicateBinding v0 -> ShowErrorCore.duplicateBindingError v0+      Errors.ErrorDuplicateField v0 -> ShowErrorCore.duplicateFieldError v0+      Errors.ErrorExtraction _ -> "extraction error"+      Errors.ErrorInference _ -> "inference error"+      Errors.ErrorOther v0 -> otherError v0+      Errors.ErrorResolution v0 -> resolutionError v0+      Errors.ErrorUndefinedField v0 -> ShowErrorCore.undefinedFieldError v0+      Errors.ErrorUndefinedTermVariable v0 -> ShowErrorCore.undefinedTermVariableError v0+      Errors.ErrorUntypedTermVariable v0 -> ShowErrorCore.untypedTermVariableError v0+      Errors.ErrorUnexpectedTermVariant v0 -> ShowErrorCore.unexpectedTermVariantError v0+      Errors.ErrorUnexpectedTypeVariant v0 -> ShowErrorCore.unexpectedTypeVariantError v0+      Errors.ErrorUnification v0 -> unificationError v0+-- | Show an incorrect unification error as a string+incorrectUnificationError :: Checking.IncorrectUnificationError -> String+incorrectUnificationError e =++      let subst = Checking.incorrectUnificationErrorSubstitution e+      in (Strings.cat2 "incorrect unification: " (ShowTyping.typeSubst subst))+-- | Show a not-a-forall-type error as a string+notAForallTypeError :: Checking.NotAForallTypeError -> String+notAForallTypeError e =++      let typ = Checking.notAForallTypeErrorType e+          args = Checking.notAForallTypeErrorTypeArguments e+      in (Strings.cat [+        "not a forall type: ",+        (ShowCore.type_ typ),+        ". Trying to apply ",+        (Literals.showInt32 (Lists.length args)),+        " type argument(s): ",+        (Formatting.showList ShowCore.type_ args)])+-- | Show a not-a-function-type error as a string+notAFunctionTypeError :: Checking.NotAFunctionTypeError -> String+notAFunctionTypeError e =++      let typ = Checking.notAFunctionTypeErrorType e+      in (Strings.cat2 "not a function type: " (ShowCore.type_ typ))+-- | Show an other error as a string+otherError :: Errors.OtherError -> String+otherError oe = Errors.unOtherError oe+-- | Show a resolution error as a string, including the offending name or shape+resolutionError :: Errors.ResolutionError -> String+resolutionError re =+    case re of+      Errors.ResolutionErrorNoSuchBinding v0 -> Strings.cat2 "no such binding: " (Core.unName (Errors.noSuchBindingErrorName v0))+      Errors.ResolutionErrorNoSuchPrimitive v0 -> Strings.cat2 "no such primitive: " (Core.unName (Errors.noSuchPrimitiveErrorName v0))+      Errors.ResolutionErrorNoMatchingField v0 -> Strings.cat2 "no matching field: " (Core.unName (Errors.noMatchingFieldErrorFieldName v0))+      Errors.ResolutionErrorOther v0 -> Strings.cat2 "resolution error: " (Errors.unOtherResolutionError v0)+      Errors.ResolutionErrorUnexpectedShape v0 -> Strings.cat [+        "unexpected shape: expected ",+        (Errors.unexpectedShapeErrorExpected v0),+        " but got ",+        (Errors.unexpectedShapeErrorActual v0)]+-- | Show a type arity mismatch error as a string+typeArityMismatchError :: Checking.TypeArityMismatchError -> String+typeArityMismatchError e =++      let typ = Checking.typeArityMismatchErrorType e+          expected = Checking.typeArityMismatchErrorExpectedArity e+          actual = Checking.typeArityMismatchErrorActualArity e+          args = Checking.typeArityMismatchErrorTypeArguments e+      in (Strings.cat [+        "type ",+        (ShowCore.type_ typ),+        " applied to the wrong number of type arguments (expected ",+        (Literals.showInt32 expected),+        ", got ",+        (Literals.showInt32 actual),+        "): ",+        (Formatting.showList ShowCore.type_ args)])+-- | Show a type mismatch error as a string+typeMismatchError :: Checking.TypeMismatchError -> String+typeMismatchError e =++      let expected = Checking.typeMismatchErrorExpectedType e+          actual = Checking.typeMismatchErrorActualType e+      in (Strings.cat [+        "type mismatch: expected ",+        (ShowCore.type_ expected),+        " but found ",+        (ShowCore.type_ actual)])+-- | Show an unbound type variables error as a string+unboundTypeVariablesError :: Checking.UnboundTypeVariablesError -> String+unboundTypeVariablesError e =++      let vars = Checking.unboundTypeVariablesErrorVariables e+          typ = Checking.unboundTypeVariablesErrorType e+      in (Strings.cat [+        "unbound type variables: {",+        (Strings.intercalate ", " (Lists.map Core.unName (Sets.toList vars))),+        "} in type ",+        (ShowCore.type_ typ)])+-- | Show an unequal types error as a string+unequalTypesError :: Checking.UnequalTypesError -> String+unequalTypesError e =++      let types = Checking.unequalTypesErrorTypes e+          desc = Checking.unequalTypesErrorDescription e+      in (Strings.cat [+        "unequal types ",+        (Formatting.showList ShowCore.type_ types),+        " in ",+        desc])+-- | Show a unification error as a string+unificationError :: Errors.UnificationError -> String+unificationError e =++      let lt = Errors.unificationErrorLeftType e+          rt = Errors.unificationErrorRightType e+          msg = Errors.unificationErrorMessage e+      in (Strings.cat [+        "unification error: cannot unify ",+        (ShowCore.type_ lt),+        " with ",+        (ShowCore.type_ rt),+        ": ",+        msg])+-- | Show an unsupported term variant error as a string+unsupportedTermVariantError :: Checking.UnsupportedTermVariantError -> String+unsupportedTermVariantError e =+    Strings.cat2 "unsupported term variant: " (ShowVariants.termVariant (Checking.unsupportedTermVariantErrorTermVariant e))+-- | Show an untyped lambda error as a string+untypedLambdaError :: t0 -> String+untypedLambdaError _ = "untyped lambda"+-- | Show an untyped let binding error as a string+untypedLetBindingError :: Checking.UntypedLetBindingError -> String+untypedLetBindingError e =++      let b = Checking.untypedLetBindingErrorBinding e+      in (Strings.cat2 "untyped let binding: " (ShowCore.binding b))
+ src/main/haskell/Hydra/Show/Graph.hs view
@@ -0,0 +1,40 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.graph types++module Hydra.Show.Graph where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Show a list of bindings as a string+graph :: [Core.Binding] -> String+graph elements =++      let elementStrs = Lists.map ShowCore.binding elements+      in (Strings.cat [+        "{",+        (Strings.intercalate ", " elementStrs),+        "}"])
+ src/main/haskell/Hydra/Show/Paths.hs view
@@ -0,0 +1,130 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Utilities for working with subterm steps and paths.++module Hydra.Show.Paths where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Convert a subterm step to a string representation+subtermStep :: Paths.SubtermStep -> Maybe String+subtermStep step =++      let idx = \i -> Nothing+          idxSuff = \suffix -> \i -> Optionals.map (\s -> Strings.cat2 s suffix) (idx i)+      in case step of+        Paths.SubtermStepAnnotatedBody -> Nothing+        Paths.SubtermStepApplicationFunction -> Just "fun"+        Paths.SubtermStepApplicationArgument -> Just "arg"+        Paths.SubtermStepLambdaBody -> Just "body"+        Paths.SubtermStepUnionCasesDefault -> Just "default"+        Paths.SubtermStepUnionCasesBranch v0 -> Just (Strings.cat2 "." (Core.unName v0))+        Paths.SubtermStepLetBody -> Just "in"+        Paths.SubtermStepLetBinding v0 -> Just (Strings.cat2 (Core.unName v0) "=")+        Paths.SubtermStepListElement v0 -> idx v0+        Paths.SubtermStepMapKey v0 -> idxSuff ".key" v0+        Paths.SubtermStepMapValue v0 -> idxSuff ".value" v0+        Paths.SubtermStepOptionalTerm -> Just "given"+        Paths.SubtermStepProductTerm v0 -> idx v0+        Paths.SubtermStepRecordField v0 -> Just (Strings.cat2 "." (Core.unName v0))+        Paths.SubtermStepSetElement v0 -> idx v0+        Paths.SubtermStepSumTerm -> Nothing+        Paths.SubtermStepTypeLambdaBody -> Nothing+        Paths.SubtermStepTypeApplicationTerm -> Nothing+        Paths.SubtermStepInjectionTerm -> Nothing+        Paths.SubtermStepWrappedTerm -> Nothing+-- | Build a subterm graph from a term+termToSubtermGraph :: M.Map Packaging.ModuleName String -> Core.Term -> Paths.SubtermGraph+termToSubtermGraph namespaces term =++      let dontCareStep = Paths.SubtermStepAnnotatedBody+          helper =+                  \ids -> \mroot -> \path -> \state -> \stepTerm ->+                    let step = Pairs.first stepTerm+                        currentTerm = Pairs.second stepTerm+                        nodesEdges = Pairs.first state+                        visited = Pairs.second state+                        nodes = Pairs.first nodesEdges+                        edges = Pairs.second nodesEdges+                        nextPath = Lists.cons step path+                    in case currentTerm of+                      Core.TermLet v0 ->+                        let bindings = Core.letBindings v0+                            env = Core.letBody v0+                            bindingNames = Lists.map Core.bindingName bindings+                            addBindingName =+                                    \nodesVisitedIds -> \name ->+                                      let currentNodesVisited = Pairs.first nodesVisitedIds+                                          currentIds = Pairs.second nodesVisitedIds+                                          currentNodes = Pairs.first currentNodesVisited+                                          currentVisited = Pairs.second currentNodesVisited+                                          rawLabel = Names.compactName namespaces name+                                          uniqueLabel = Names.uniqueLabel currentVisited rawLabel+                                          node =+                                                  Paths.SubtermNode {+                                                    Paths.subtermNodeName = name,+                                                    Paths.subtermNodeLabel = rawLabel,+                                                    Paths.subtermNodeId = uniqueLabel}+                                          newVisited = Sets.insert uniqueLabel currentVisited+                                          newNodes = Lists.cons node currentNodes+                                          newIds = Maps.insert name node currentIds+                                      in ((newNodes, newVisited), newIds)+                            nodesVisitedIds1 = Lists.foldl addBindingName (([], visited), ids) bindingNames+                            nodes1 = Pairs.first (Pairs.first nodesVisitedIds1)+                            visited1 = Pairs.second (Pairs.first nodesVisitedIds1)+                            ids1 = Pairs.second nodesVisitedIds1+                            addBindingTerm =+                                    \currentState -> \nodeBinding ->+                                      let root = Pairs.first nodeBinding+                                          binding = Pairs.second nodeBinding+                                          term1 = Core.bindingTerm binding+                                      in (helper ids1 (Just root) [] currentState (dontCareStep, term1))+                            nodeBindingPairs = Lists.zip nodes1 bindings+                            stateAfterBindings = Lists.foldl addBindingTerm ((Lists.concat2 nodes1 nodes, edges), visited1) nodeBindingPairs+                        in (helper ids1 mroot nextPath stateAfterBindings (Paths.SubtermStepLetBody, env))+                      Core.TermVariable v0 -> Optionals.cases mroot state (\root -> Optionals.cases (Maps.lookup v0 ids) state (\node ->+                        let edge =+                                Paths.SubtermEdge {+                                  Paths.subtermEdgeSource = root,+                                  Paths.subtermEdgePath = (Paths.SubtermPath (Lists.reverse nextPath)),+                                  Paths.subtermEdgeTarget = node}+                            newEdges = Lists.cons edge edges+                        in ((nodes, newEdges), visited)))+                      _ -> Lists.foldl (helper ids mroot nextPath) state (Rewriting.subtermsWithSteps currentTerm)+          initialState = (([], []), Sets.empty)+          result = helper Maps.empty Nothing [] initialState (dontCareStep, term)+          finalNodesEdges = Pairs.first result+          finalNodes = Pairs.first finalNodesEdges+          finalEdges = Pairs.second finalNodesEdges+      in Paths.SubtermGraph {+        Paths.subtermGraphNodes = finalNodes,+        Paths.subtermGraphEdges = finalEdges}
+ src/main/haskell/Hydra/Show/Typing.hs view
@@ -0,0 +1,62 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.typing types++module Hydra.Show.Typing where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Show a type constraint as a string+typeConstraint :: Typing.TypeConstraint -> String+typeConstraint tc =++      let ltyp = Typing.typeConstraintLeft tc+          rtyp = Typing.typeConstraintRight tc+      in (Strings.cat [+        ShowCore.type_ ltyp,+        "\8801",+        (ShowCore.type_ rtyp)])+-- | Show a type substitution as a string+typeSubst :: Typing.TypeSubst -> String+typeSubst ts =++      let subst = Typing.unTypeSubst ts+          pairs = Maps.toList subst+          showPair =+                  \pair ->+                    let name = Core.unName (Pairs.first pair)+                        typ = Pairs.second pair+                    in (Strings.cat [+                      name,+                      "\8614",+                      (ShowCore.type_ typ)])+          pairStrs = Lists.map showPair pairs+      in (Strings.cat [+        "{",+        (Strings.intercalate "," pairStrs),+        "}"])
+ src/main/haskell/Hydra/Show/Util.hs view
@@ -0,0 +1,43 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.util types++module Hydra.Show.Util where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Show a case convention as a string+caseConvention :: Util.CaseConvention -> String+caseConvention c =+    case c of+      Util.CaseConventionLowerSnake -> "lower_snake_case"+      Util.CaseConventionUpperSnake -> "UPPER_SNAKE_CASE"+      Util.CaseConventionCamel -> "camelCase"+      Util.CaseConventionPascal -> "PascalCase"+-- | Show a comparison result as a string+comparison :: Util.Comparison -> String+comparison c =+    case c of+      Util.ComparisonLessThan -> "lessThan"+      Util.ComparisonEqualTo -> "equalTo"+      Util.ComparisonGreaterThan -> "greaterThan"
+ src/main/haskell/Hydra/Show/Variants.hs view
@@ -0,0 +1,74 @@+-- Note: this is an automatically generated file. Do not edit.+-- | String representations of hydra.variants types++module Hydra.Show.Variants where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Show a term variant as a string+termVariant :: Variants.TermVariant -> String+termVariant x =+    case x of+      Variants.TermVariantAnnotated -> "annotated"+      Variants.TermVariantApplication -> "application"+      Variants.TermVariantCases -> "cases"+      Variants.TermVariantEither -> "either"+      Variants.TermVariantLambda -> "lambda"+      Variants.TermVariantLet -> "let"+      Variants.TermVariantList -> "list"+      Variants.TermVariantLiteral -> "literal"+      Variants.TermVariantMap -> "map"+      Variants.TermVariantOptional -> "optional"+      Variants.TermVariantPair -> "pair"+      Variants.TermVariantProject -> "project"+      Variants.TermVariantRecord -> "record"+      Variants.TermVariantSet -> "set"+      Variants.TermVariantTypeLambda -> "typeLambda"+      Variants.TermVariantTypeApplication -> "typeApplication"+      Variants.TermVariantInject -> "inject"+      Variants.TermVariantUnit -> "unit"+      Variants.TermVariantUnwrap -> "unwrap"+      Variants.TermVariantVariable -> "variable"+      Variants.TermVariantWrap -> "wrap"+-- | Show a type variant as a string+typeVariant :: Variants.TypeVariant -> String+typeVariant x =+    case x of+      Variants.TypeVariantAnnotated -> "annotated"+      Variants.TypeVariantApplication -> "application"+      Variants.TypeVariantEither -> "either"+      Variants.TypeVariantForall -> "forall"+      Variants.TypeVariantFunction -> "function"+      Variants.TypeVariantList -> "list"+      Variants.TypeVariantLiteral -> "literal"+      Variants.TypeVariantMap -> "map"+      Variants.TypeVariantOptional -> "optional"+      Variants.TypeVariantPair -> "pair"+      Variants.TypeVariantRecord -> "record"+      Variants.TypeVariantSet -> "set"+      Variants.TypeVariantUnion -> "union"+      Variants.TypeVariantUnit -> "unit"+      Variants.TypeVariantVariable -> "variable"+      Variants.TypeVariantVoid -> "void"+      Variants.TypeVariantWrap -> "wrap"
+ src/main/haskell/Hydra/Sorting.hs view
@@ -0,0 +1,229 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Utilities for sorting. This module includes an implementation of Tarjan's algorithm, originally based on GraphSCC by Iavor S. Diatchki: https://hackage.haskell.org/package/GraphSCC. Tarjan was chosen because it computes strongly connected components in O(V+E), in a single pass, and yields the components in reverse topological order — exactly the shape every consumer in the kernel (HM let-generalization, schema graph construction, target-language emission) needs.++module Hydra.Sorting where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Equality as Equality+import qualified Hydra.Haskell.Lib.Lists as Lists+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.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Convert an adjacency list to a map, concatenating values for duplicate keys+adjacencyListToMap :: Ord t0 => ([(t0, [t1])] -> M.Map t0 [t1])+adjacencyListToMap pairs =+    Lists.foldl (\mp -> \p ->+      let k = Pairs.first p+          vs = Pairs.second p+          existing = Optionals.cases (Maps.lookup k mp) [] Equality.identity+      in (Maps.insert k (Lists.concat2 existing vs) mp)) Maps.empty pairs+-- | Given a list of adjacency lists represented as (key, [key]) pairs, construct a graph along with a function mapping each vertex (an Int) back to its original key (Nothing for unknown vertices).+adjacencyListsToGraph :: Ord t0 => ([(t0, [t0])] -> (M.Map Int [Int], (Int -> Maybe t0)))+adjacencyListsToGraph edges0 =++      let sortedEdges = Lists.sortOn Pairs.first edges0+          indexedEdges = Lists.zip (Math.range 0 (Lists.length sortedEdges)) sortedEdges+          keyToVertex =+                  Maps.fromList (Lists.map (\vkNeighbors ->+                    let v = Pairs.first vkNeighbors+                        kNeighbors = Pairs.second vkNeighbors+                        k = Pairs.first kNeighbors+                    in (k, v)) indexedEdges)+          vertexMap =+                  Maps.fromList (Lists.map (\vkNeighbors ->+                    let v = Pairs.first vkNeighbors+                        kNeighbors = Pairs.second vkNeighbors+                        k = Pairs.first kNeighbors+                    in (v, k)) indexedEdges)+          graph =+                  Maps.fromList (Lists.map (\vkNeighbors ->+                    let v = Pairs.first vkNeighbors+                        kNeighbors = Pairs.second vkNeighbors+                        neighbors = Pairs.second kNeighbors+                    in (v, (Optionals.mapOptional (\k -> Maps.lookup k keyToVertex) neighbors))) indexedEdges)+          vertexToKey = \v -> Maps.lookup v vertexMap+      in (graph, vertexToKey)+-- | Construct an OrderingIsomorphism between two orderings of the same elements. The two list arguments must be permutations of each other; the result is a pair of mappings that transport an element list from one ordering to the other.+createOrderingIsomorphism :: Ord t0 => ([t0] -> [t0] -> Topology.OrderingIsomorphism t1)+createOrderingIsomorphism sourceOrd targetOrd =++      let sourceToTargetMapping =+              \els ->+                let mp = Maps.fromList (Lists.zip sourceOrd els)+                in (Optionals.cat (Lists.map (\n -> Maps.lookup n mp) targetOrd))+          targetToSourceMapping =+                  \els ->+                    let mp = Maps.fromList (Lists.zip targetOrd els)+                    in (Optionals.cat (Lists.map (\n -> Maps.lookup n mp) sourceOrd))+      in Topology.OrderingIsomorphism {+        Topology.orderingIsomorphismEncode = sourceToTargetMapping,+        Topology.orderingIsomorphismDecode = targetToSourceMapping}+-- | Given an adjacency function and a distinguished root node, find all reachable nodes (including the root node)+findReachableNodes :: Ord t0 => ((t0 -> S.Set t0) -> t0 -> S.Set t0)+findReachableNodes adj root =++      let visit =+              \visited -> \node ->+                let toVisit = Sets.difference (adj node) visited+                in (Logic.ifElse (Sets.null toVisit) visited (Lists.foldl (\v -> \n -> visit (Sets.insert n v) n) visited (Sets.toList toVisit)))+      in (visit (Sets.singleton root) root)+-- | Initial state for Tarjan's algorithm+initialState :: Topology.TarjanState+initialState =+    Topology.TarjanState {+      Topology.tarjanStateCounter = 0,+      Topology.tarjanStateIndices = Maps.empty,+      Topology.tarjanStateLowLinks = Maps.empty,+      Topology.tarjanStateStack = [],+      Topology.tarjanStateOnStack = Sets.empty,+      Topology.tarjanStateSccs = []}+-- | Pop vertices off the stack until the given vertex is reached, collecting the current strongly connected component+popStackUntil :: Int -> Topology.TarjanState -> ([Int], Topology.TarjanState)+popStackUntil v st0 =++      let go =+              \acc -> \st -> Optionals.cases (Lists.uncons (Topology.tarjanStateStack st)) (Lists.reverse acc, st) (\uc ->+                let x = Pairs.first uc+                    xs = Pairs.second uc+                    newSt =+                            Topology.TarjanState {+                              Topology.tarjanStateCounter = (Topology.tarjanStateCounter st),+                              Topology.tarjanStateIndices = (Topology.tarjanStateIndices st),+                              Topology.tarjanStateLowLinks = (Topology.tarjanStateLowLinks st),+                              Topology.tarjanStateStack = xs,+                              Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack st),+                              Topology.tarjanStateSccs = (Topology.tarjanStateSccs st)}+                    newSt2 =+                            Topology.TarjanState {+                              Topology.tarjanStateCounter = (Topology.tarjanStateCounter newSt),+                              Topology.tarjanStateIndices = (Topology.tarjanStateIndices newSt),+                              Topology.tarjanStateLowLinks = (Topology.tarjanStateLowLinks newSt),+                              Topology.tarjanStateStack = (Topology.tarjanStateStack newSt),+                              Topology.tarjanStateOnStack = (Sets.delete x (Topology.tarjanStateOnStack st)),+                              Topology.tarjanStateSccs = (Topology.tarjanStateSccs newSt)}+                    acc_ = Lists.cons x acc+                in (Logic.ifElse (Equality.equal x v) (Lists.reverse acc_, newSt2) (go acc_ newSt2)))+      in (go [] st0)+-- | Given a graph as an adjacency list of edges and a list of explicit tags per node, compute the full set of tags for each node by propagating tags through edges. If there is an edge from n1 to n2 and n2 has tag t, then n1 also has tag t. Note: pairs in the output are not ordered.+propagateTags :: (Ord t0, Ord t1) => ([(t0, [t0])] -> [(t0, [t1])] -> [(t0, (S.Set t1))])+propagateTags edges nodeTags =++      let adjMap = adjacencyListToMap edges+          tagMap = Maps.map Sets.fromList (adjacencyListToMap nodeTags)+          allNodes = Sets.toList (Sets.fromList (Lists.concat2 (Lists.map Pairs.first edges) (Lists.map Pairs.first nodeTags)))+          getTagsForNode =+                  \node ->+                    let reachable = findReachableNodes (\n -> Sets.fromList (Optionals.cases (Maps.lookup n adjMap) [] Equality.identity)) node+                    in (Sets.unions (Lists.map (\n -> Optionals.cases (Maps.lookup n tagMap) Sets.empty Equality.identity) (Sets.toList reachable)))+      in (Lists.map (\n -> (n, (getTagsForNode n))) allNodes)+-- | Visit a vertex and recursively explore its successors+strongConnect :: M.Map Int [Int] -> Int -> Topology.TarjanState -> Topology.TarjanState+strongConnect graph v st =++      let i = Topology.tarjanStateCounter st+          newSt =+                  Topology.TarjanState {+                    Topology.tarjanStateCounter = (Math.add i 1),+                    Topology.tarjanStateIndices = (Maps.insert v i (Topology.tarjanStateIndices st)),+                    Topology.tarjanStateLowLinks = (Maps.insert v i (Topology.tarjanStateLowLinks st)),+                    Topology.tarjanStateStack = (Lists.cons v (Topology.tarjanStateStack st)),+                    Topology.tarjanStateOnStack = (Sets.insert v (Topology.tarjanStateOnStack st)),+                    Topology.tarjanStateSccs = (Topology.tarjanStateSccs st)}+          neighbors = Maps.findWithDefault [] v graph+          processNeighbor =+                  \st_ -> \w ->+                    let lowLink =+                            \s ->+                              let lowV1 = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateLowLinks s)+                                  idx_w = Maps.findWithDefault Constants.maxInt32 w (Topology.tarjanStateIndices s)+                              in Topology.TarjanState {+                                Topology.tarjanStateCounter = (Topology.tarjanStateCounter s),+                                Topology.tarjanStateIndices = (Topology.tarjanStateIndices s),+                                Topology.tarjanStateLowLinks = (Maps.insert v (Equality.min lowV1 idx_w) (Topology.tarjanStateLowLinks s)),+                                Topology.tarjanStateStack = (Topology.tarjanStateStack s),+                                Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack s),+                                Topology.tarjanStateSccs = (Topology.tarjanStateSccs s)}+                    in (Logic.ifElse (Logic.not (Maps.member w (Topology.tarjanStateIndices st_))) (+                      let stAfter = strongConnect graph w st_+                          lowV2 = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateLowLinks stAfter)+                          low_w = Maps.findWithDefault Constants.maxInt32 w (Topology.tarjanStateLowLinks stAfter)+                      in Topology.TarjanState {+                        Topology.tarjanStateCounter = (Topology.tarjanStateCounter stAfter),+                        Topology.tarjanStateIndices = (Topology.tarjanStateIndices stAfter),+                        Topology.tarjanStateLowLinks = (Maps.insert v (Equality.min lowV2 low_w) (Topology.tarjanStateLowLinks stAfter)),+                        Topology.tarjanStateStack = (Topology.tarjanStateStack stAfter),+                        Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack stAfter),+                        Topology.tarjanStateSccs = (Topology.tarjanStateSccs stAfter)}) (Logic.ifElse (Sets.member w (Topology.tarjanStateOnStack st_)) (lowLink st_) st_))+          stAfterNeighbors = Lists.foldl processNeighbor newSt neighbors+          low_v = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateLowLinks stAfterNeighbors)+          idx_v = Maps.findWithDefault Constants.maxInt32 v (Topology.tarjanStateIndices stAfterNeighbors)+      in (Logic.ifElse (Equality.equal low_v idx_v) (+        let compResult = popStackUntil v stAfterNeighbors+            comp = Pairs.first compResult+            stPopped = Pairs.second compResult+        in Topology.TarjanState {+          Topology.tarjanStateCounter = (Topology.tarjanStateCounter stPopped),+          Topology.tarjanStateIndices = (Topology.tarjanStateIndices stPopped),+          Topology.tarjanStateLowLinks = (Topology.tarjanStateLowLinks stPopped),+          Topology.tarjanStateStack = (Topology.tarjanStateStack stPopped),+          Topology.tarjanStateOnStack = (Topology.tarjanStateOnStack stPopped),+          Topology.tarjanStateSccs = (Lists.cons comp (Topology.tarjanStateSccs stPopped))}) stAfterNeighbors)+-- | Compute the strongly connected components of the given graph. The components are returned in reverse topological order+stronglyConnectedComponents :: M.Map Int [Int] -> [[Int]]+stronglyConnectedComponents graph =++      let verts = Maps.keys graph+          finalState =+                  Lists.foldl (\st -> \v -> Logic.ifElse (Maps.member v (Topology.tarjanStateIndices st)) st (strongConnect graph v st)) initialState verts+      in (Lists.reverse (Lists.map Lists.sort (Topology.tarjanStateSccs finalState)))+-- | Sort a directed acyclic graph (DAG) based on an adjacency list. Yields a list of nontrivial strongly connected components if the graph has cycles, otherwise a simple list.+topologicalSort :: Ord t0 => ([(t0, [t0])] -> Either [[t0]] [t0])+topologicalSort pairs =++      let sccs = topologicalSortComponents pairs+          isCycle = \scc -> Equality.gt (Lists.length scc) 1+          withCycles = Lists.filter isCycle sccs+      in (Logic.ifElse (Lists.null withCycles) (Right (Lists.concat sccs)) (Left withCycles))+-- | Find the strongly connected components (including cycles and isolated vertices) of a graph, in (reverse) topological order, i.e. dependencies before dependents+topologicalSortComponents :: Ord t0 => ([(t0, [t0])] -> [[t0]])+topologicalSortComponents pairs =++      let graphResult = adjacencyListsToGraph pairs+          g = Pairs.first graphResult+      in (Lists.map (\comp -> Optionals.mapOptional (Pairs.second graphResult) comp) (stronglyConnectedComponents g))+-- | Sort a directed acyclic graph (DAG) of nodes using two helper functions: one for node keys, and one for the adjacency list of connected node keys. The result is a list of strongly-connected components (cycles), in which singleton lists represent acyclic nodes.+topologicalSortNodes :: Ord t1 => ((t0 -> t1) -> (t0 -> [t1]) -> [t0] -> [[t0]])+topologicalSortNodes getKey getAdj nodes =++      let nodesByKey = Maps.fromList (Lists.map (\n -> (getKey n, n)) nodes)+          pairs = Lists.map (\n -> (getKey n, (getAdj n))) nodes+          comps = topologicalSortComponents pairs+      in (Lists.map (\c -> Optionals.cat (Lists.map (\k -> Maps.lookup k nodesByKey) c)) comps)
+ src/main/haskell/Hydra/Sources/Decode/Ast.hs view
@@ -0,0 +1,2441 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.ast++module Hydra.Sources.Decode.Ast where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.ast"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.ast"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.ast"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.associativity"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Associativity"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "none"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "left"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "right"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "both"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Associativity"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "both"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Associativity")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.blockStyle"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.BlockStyle"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.BlockStyle"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "indent"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "cx"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "raw"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "err"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "stripped"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                            Core.caseStatementCases = [+                                                              Core.CaseAlternative {+                                                                Core.caseAlternativeName = (Core.Name "literal"),+                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "v"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                      Core.caseStatementCases = [+                                                                        Core.CaseAlternative {+                                                                          Core.caseAlternativeName = (Core.Name "string"),+                                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                            Core.lambdaParameter = (Core.Name "s"),+                                                                            Core.lambdaDomain = Nothing,+                                                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_indent"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "newlineBeforeContent"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "boolean"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "b"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_newlineBeforeContent"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "newlineAfterContent"))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "boolean"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "b"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_newlineAfterContent"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.ast.BlockStyle"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "indent"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_indent"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "newlineBeforeContent"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_newlineBeforeContent"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "newlineAfterContent"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_newlineAfterContent"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.BlockStyle")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.bracketExpr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.BracketExpr"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.BracketExpr"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "brackets"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.brackets"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_brackets"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "enclosed"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_enclosed"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "style"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.blockStyle"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_style"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.ast.BracketExpr"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "brackets"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_brackets"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "enclosed"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_enclosed"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "style"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_style"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.BracketExpr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.brackets"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Brackets"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.Brackets"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "open"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_open"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "close"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_close"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.ast.Brackets"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "open"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_open"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "close"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_close"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Brackets")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.expr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Expr"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "const"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "const"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indent"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "indent"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.indentedExpression")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "op"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.opExpr")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "brackets"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "brackets"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.bracketExpr")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "seq"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Expr"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "seq"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.ast.seqExpr")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Expr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.indentStyle"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.IndentStyle"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "allLines"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "allLines"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subsequentLines"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.IndentStyle"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "subsequentLines"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.IndentStyle")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.indentedExpression"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.IndentedExpression"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.IndentedExpression"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "style"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.indentStyle"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_style"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expr"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_expr"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.ast.IndentedExpression"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "style"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_style"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "expr"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_expr"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.IndentedExpression")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.op"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Op"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.Op"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "symbol"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.symbol"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_symbol"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "padding"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.padding"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_padding"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "precedence"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.precedence"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_precedence"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "associativity"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.associativity"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_associativity"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.ast.Op"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "symbol"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_symbol"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "padding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_padding"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "precedence"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_precedence"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "associativity"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_associativity"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Op")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.opExpr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.OpExpr"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.OpExpr"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "op"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.op"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_op"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "lhs"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_lhs"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rhs"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_rhs"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.ast.OpExpr"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "op"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_op"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "lhs"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_lhs"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "rhs"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_rhs"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.OpExpr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.padding"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Padding"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.Padding"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.ws"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_left"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.ws"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_right"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.ast.Padding"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "left"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "right"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Padding")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.precedence"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Precedence"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.ast.Precedence"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "integer"),+                                                                  Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "int32"),+                                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                          Core.lambdaParameter = (Core.Name "i"),+                                                                          Core.lambdaDomain = Nothing,+                                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Precedence")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.seqExpr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.SeqExpr"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.ast.SeqExpr"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "op"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.op"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_op"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "elements"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.ast.expr"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_elements"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.ast.SeqExpr"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "op"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_op"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "elements"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_elements"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.SeqExpr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.symbol"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Symbol"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.ast.Symbol"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Symbol")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.ast.ws"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.ast.Ws"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "none"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "space"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "space"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "break"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "break"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "breakAndIndent"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "breakAndIndent"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "doubleBreak"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.ast.Ws"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "doubleBreak"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.ast.Ws")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Coders.hs view
@@ -0,0 +1,1016 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.coders++module Hydra.Sources.Decode.Coders where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.coders"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.coders"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.coders"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.errors"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.graph"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.util"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.caseConventions"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.CaseConventions"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.coders.CaseConventions"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "constant"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_constant"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "directory"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_directory"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "enumValue"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_enumValue"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "field"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_field"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "file"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "field_file"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "module"))})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "field_module"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "field_term"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "termVariable"))})),+                                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "field_termVariable"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "field_type"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeVariable"))})),+                                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                          Core.lambdaParameter = (Core.Name "field_typeVariable"),+                                                                          Core.lambdaDomain = Nothing,+                                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                                            Core.recordTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                                                            Core.recordFields = [+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "constant"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_constant"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "directory"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_directory"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "enumValue"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_enumValue"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "field"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_field"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "file"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_file"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "module"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_module"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "term"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "termVariable"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_termVariable"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "type"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},+                                                                              Core.Field {+                                                                                Core.fieldName = (Core.Name "typeVariable"),+                                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeVariable"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.CaseConventions")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.coderDirection"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "encode"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "encode"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decode"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.coders.CoderDirection"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "decode"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.CoderDirection")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.languageFeature"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.LanguageFeature"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "partialApplication"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "partialApplication"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedCaseStatements"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "nestedCaseStatements"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedPolymorphicLetBindings"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.coders.LanguageFeature"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "nestedPolymorphicLetBindings"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.LanguageFeature")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.languageName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.LanguageName"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.coders.LanguageName"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.LanguageName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.coders.traversalOrder"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.coders.TraversalOrder"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pre"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pre"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "post"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.coders.TraversalOrder"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "post"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.coders.TraversalOrder")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Core.hs view
@@ -0,0 +1,6527 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.core++module Hydra.Sources.Decode.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.core"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.core"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.annotatedTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedTerm"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.AnnotatedTerm"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_body"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "annotation"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_annotation"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "body"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "annotation"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_annotation"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.AnnotatedTerm")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.annotatedType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.AnnotatedType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_body"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "annotation"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_annotation"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.AnnotatedType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "body"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "annotation"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_annotation"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.AnnotatedType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.application"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Application"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Application"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "function"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_function"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "argument"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_argument"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.Application"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "function"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_function"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "argument"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_argument"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Application")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.applicationType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.ApplicationType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.ApplicationType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "function"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_function"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "argument"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_argument"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.ApplicationType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "function"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_function"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "argument"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_argument"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.ApplicationType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.binding"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Binding"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Binding"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_term"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeScheme"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeScheme"))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_typeScheme"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.core.Binding"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "name"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "term"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "typeScheme"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeScheme"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Binding")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.caseAlternative"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.CaseAlternative"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.CaseAlternative"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "handler"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_handler"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.CaseAlternative"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "handler"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_handler"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.CaseAlternative")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.caseStatement"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.CaseStatement"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.CaseStatement"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_typeName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "default"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_default"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "cases"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.caseAlternative"))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_cases"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.core.CaseStatement"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "typeName"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "default"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_default"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "cases"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_cases"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.CaseStatement")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.eitherType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.EitherType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.EitherType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_left"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_right"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.EitherType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "left"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "right"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.EitherType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.field"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Field"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Field"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_term"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "term"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Field")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.fieldType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FieldType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.FieldType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_type"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.FieldType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "type"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FieldType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.floatType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FloatType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "float32"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.FloatType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "float64"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FloatType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.floatValue"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FloatValue"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "float32"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "float"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "float32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "f"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "float64"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float64 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "float"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected float64 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "float64"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "f"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "f"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FloatValue")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.forallType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.ForallType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.ForallType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_parameter"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_body"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.ForallType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "parameter"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "body"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.ForallType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.functionType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.FunctionType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.FunctionType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_domain"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "codomain"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_codomain"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.FunctionType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "domain"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "codomain"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_codomain"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.FunctionType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.injection"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Injection"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Injection"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_typeName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "field"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.field"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_field"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "field"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_field"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Injection")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.integerType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.IntegerType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "bigint"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int8"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int16"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int32"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int64"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint8"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint16"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint32"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint64"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.IntegerType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.integerValue"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.IntegerValue"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "bigint"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigint literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected bigint value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "bigint"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int8"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int8 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int8 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int8"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int16"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int16 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int16 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int16"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int32"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "int64"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int64 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int64 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int64"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint8"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint8 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint8 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "uint8"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint16"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint16 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint16 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "uint16"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint32"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "uint32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "uint64"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint64 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected uint64 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "uint64"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.IntegerValue")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.lambda"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Lambda"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Lambda"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_parameter"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_domain"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_body"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.core.Lambda"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "parameter"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "domain"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "body"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Lambda")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.let"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Let"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Let"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "bindings"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_bindings"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_body"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.Let"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "bindings"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_bindings"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "body"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Let")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.literal"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Literal"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "binary"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected binary literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "binary"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "b"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "boolean"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "boolean"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "b"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "decimal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected decimal literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "decimal"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "d"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "d"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "float"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.floatValue")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "integer"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.integerValue")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "string"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Literal")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.literalType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.LiteralType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "binary"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "boolean"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "decimal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "float"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.floatType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "integer"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.integerType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.LiteralType"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "string"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.LiteralType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.mapType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.MapType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.MapType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keys"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_keys"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "values"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_values"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.MapType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "keys"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_keys"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "values"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_values"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.MapType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.name"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Name"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Name")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.pairType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.PairType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.PairType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "first"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_first"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "second"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_second"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.PairType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "first"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_first"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "second"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_second"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.PairType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.projection"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Projection"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Projection"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_typeName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_fieldName"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.Projection"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "fieldName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Projection")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.record"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Record"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.Record"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_typeName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fields"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.field"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_fields"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.Record"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "fields"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_fields"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Record")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.term"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Term"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "annotated"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.annotatedTerm")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "application"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.application")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "cases"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.caseStatement")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "either"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeEither")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inject"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "inject"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.injection")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambda"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "lambda"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.lambda")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "let"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "let"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.let")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "list"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "literal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.literal")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "map"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "optional"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pair"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodePair")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "project"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.projection")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "record"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.record")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "set"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplication"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeApplication"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.typeApplicationTerm")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambda"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeLambda"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.typeLambda")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unit"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unwrap"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unwrap"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "variable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "wrap"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.wrappedTerm")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Term")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.type"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Type"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "annotated"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.annotatedType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "application"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.applicationType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "either"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.eitherType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forall"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "forall"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.forallType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "function"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.functionType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "list"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "literal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.literalType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "map"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.mapType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "optional"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pair"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.pairType")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "record"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.fieldType"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "set"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "union"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.fieldType"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unit"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "variable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "void"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "void"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.Type"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "wrap"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.type")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.Type")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeApplicationTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeApplicationTerm"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.TypeApplicationTerm"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_body"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_type"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "body"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "type"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeApplicationTerm")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeClassConstraint"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeClassConstraint"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "simple"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.core.TypeClassConstraint"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "simple"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeClassConstraint")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeLambda"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeLambda"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.TypeLambda"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameter"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_parameter"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_body"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.TypeLambda"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "parameter"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameter"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "body"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeLambda")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeScheme"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.TypeScheme"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_variables"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_body"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "constraints"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeVariableConstraints"))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_constraints"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.core.TypeScheme"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "variables"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "body"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "constraints"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_constraints"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeScheme")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.typeVariableConstraints"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableConstraints"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.TypeVariableConstraints"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "classes"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeClassConstraint"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_classes"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.core.TypeVariableConstraints"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "classes"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_classes"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.TypeVariableConstraints")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.core.wrappedTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.core.WrappedTerm"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_typeName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_body"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "body"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.core.WrappedTerm")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs view
@@ -0,0 +1,2013 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.error.checking++module Hydra.Sources.Decode.Error.Checking where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.error.checking"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.error.checking"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.checking"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.checkingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "incorrectUnification"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "incorrectUnification"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.incorrectUnificationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAForallType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "notAForallType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.notAForallTypeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAFunctionType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "notAFunctionType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.notAFunctionTypeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "other"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.otherCheckingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArityMismatch"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeArityMismatch"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.typeArityMismatchError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeMismatch"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeMismatch"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.typeMismatchError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unboundTypeVariables"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unboundTypeVariables"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.unboundTypeVariablesError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedTermVariable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.undefinedTermVariableCheckingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unequalTypes"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unequalTypes"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.unequalTypesError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupportedTermVariant"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unsupportedTermVariant"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.unsupportedTermVariantError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLambda"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "untypedLambda"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.untypedLambdaError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLetBinding"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "untypedLetBinding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.untypedLetBindingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.checking.CheckingError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "untypedTermVariable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.untypedTermVariableCheckingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.CheckingError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.incorrectUnificationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.IncorrectUnificationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.IncorrectUnificationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "substitution"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.typeSubst"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_substitution"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "substitution"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_substitution"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.IncorrectUnificationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.notAForallTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAForallTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.NotAForallTypeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_type"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeArguments"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_typeArguments"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "type"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeArguments"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeArguments"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.NotAForallTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.notAFunctionTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAFunctionTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.NotAFunctionTypeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_type"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "type"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.NotAFunctionTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.otherCheckingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.OtherCheckingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.OtherCheckingError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_path"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_message"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "path"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "message"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.OtherCheckingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.typeArityMismatchError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeArityMismatchError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.TypeArityMismatchError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_type"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedArity"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "integer"),+                                                                            Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                              Core.caseStatementCases = [+                                                                                Core.CaseAlternative {+                                                                                  Core.caseAlternativeName = (Core.Name "int32"),+                                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                    Core.lambdaParameter = (Core.Name "i"),+                                                                                    Core.lambdaDomain = Nothing,+                                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_expectedArity"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualArity"))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_actualArity"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeArguments"))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_typeArguments"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "type"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "expectedArity"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedArity"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "actualArity"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualArity"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "typeArguments"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeArguments"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.TypeArityMismatchError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.typeMismatchError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeMismatchError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.TypeMismatchError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedType"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_expectedType"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_actualType"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "expectedType"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedType"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "actualType"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.TypeMismatchError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.unboundTypeVariablesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnboundTypeVariablesError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.UnboundTypeVariablesError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_variables"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_type"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "variables"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "type"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UnboundTypeVariablesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.undefinedTermVariableCheckingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.UndefinedTermVariableCheckingError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_path"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "path"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UndefinedTermVariableCheckingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.unequalTypesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnequalTypesError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.UnequalTypesError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "types"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_types"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_description"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "types"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_types"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "description"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UnequalTypesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.unsupportedTermVariantError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UnsupportedTermVariantError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.UnsupportedTermVariantError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "termVariant"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.termVariant"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_termVariant"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "termVariant"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_termVariant"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UnsupportedTermVariantError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedLambdaError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLambdaError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.UntypedLambdaError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                    Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLambdaError"),+                                    Core.recordFields = []}))))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UntypedLambdaError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedLetBindingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLetBindingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.UntypedLetBindingError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "binding"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_binding"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "binding"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_binding"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UntypedLetBindingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.checking.untypedTermVariableCheckingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.checking.UntypedTermVariableCheckingError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_path"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "path"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.checking.UntypedTermVariableCheckingError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Error/Core.hs view
@@ -0,0 +1,5438 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.error.core++module Hydra.Sources.Decode.Error.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.error.core"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.error.core"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.constantConditionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.ConstantConditionError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.ConstantConditionError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "value"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "boolean"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "b"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_value"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "value"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_value"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.ConstantConditionError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateBindingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateBindingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.DuplicateBindingError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateBindingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateFieldError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateFieldError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.DuplicateFieldError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateFieldError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateRecordTypeFieldNamesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.DuplicateRecordTypeFieldNamesError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateRecordTypeFieldNamesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.duplicateUnionTypeFieldNamesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.DuplicateUnionTypeFieldNamesError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.DuplicateUnionTypeFieldNamesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyCaseStatementError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyCaseStatementError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.EmptyCaseStatementError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_typeName"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyCaseStatementError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyLetBindingsError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyLetBindingsError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.EmptyLetBindingsError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyLetBindingsError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyRecordTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyRecordTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.EmptyRecordTypeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyRecordTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTermAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTermAnnotationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.EmptyTermAnnotationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyTermAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTypeAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeAnnotationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.EmptyTypeAnnotationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyTypeAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyTypeNameInTermError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeNameInTermError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.EmptyTypeNameInTermError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyTypeNameInTermError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.emptyUnionTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyUnionTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.EmptyUnionTypeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.EmptyUnionTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidForallParameterNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidForallParameterNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.InvalidForallParameterNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidForallParameterNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLambdaParameterNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.InvalidLambdaParameterNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidLambdaParameterNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLetBindingNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLetBindingNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.InvalidLetBindingNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidLetBindingNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidLiteralError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLiteralError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeMismatch"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidLiteralError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeMismatch"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.literalTypeMismatchError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidLiteralError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTermError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTermError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constantCondition"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "constantCondition"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.constantConditionError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateBinding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateBindingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateFieldError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyCaseStatement"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyCaseStatement"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyCaseStatementError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyLetBindings"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyLetBindings"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyLetBindingsError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTermAnnotation"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyTermAnnotation"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyTermAnnotationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeNameInTerm"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyTypeNameInTerm"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyTypeNameInTermError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLambdaParameterName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidLambdaParameterName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidLambdaParameterNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLetBindingName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidLetBindingName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidLetBindingNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeLambdaParameterName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidTypeLambdaParameterName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidTypeLambdaParameterNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTermAnnotation"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "nestedTermAnnotation"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nestedTermAnnotationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "redundantWrapUnwrap"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "redundantWrapUnwrap"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.redundantWrapUnwrapError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "selfApplication"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "selfApplication"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.selfApplicationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariableShadowing"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "termVariableShadowing"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.termVariableShadowingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInTypeLambda"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeVariableShadowingInTypeLambda"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.typeVariableShadowingInTypeLambdaError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedTermVariable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTermVariableError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInBindingType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedTypeVariableInBindingType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableInBindingTypeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInLambdaDomain"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedTypeVariableInLambdaDomain"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableInLambdaDomainError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInTypeApplication"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedTypeVariableInTypeApplication"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableInTypeApplicationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unknownPrimitiveName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unknownPrimitiveName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unknownPrimitiveNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unnecessaryIdentityApplication"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unnecessaryIdentityApplication"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unnecessaryIdentityApplicationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "untypedTermVariable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.untypedTermVariableError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTermError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateRecordTypeFieldNames"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateRecordTypeFieldNames"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateRecordTypeFieldNamesError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateUnionTypeFieldNames"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateUnionTypeFieldNames"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateUnionTypeFieldNamesError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyRecordType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyRecordType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyRecordTypeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeAnnotation"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyTypeAnnotation"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyTypeAnnotationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyUnionType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyUnionType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.emptyUnionTypeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidForallParameterName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidForallParameterName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidForallParameterNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeSchemeVariableName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidTypeSchemeVariableName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidTypeSchemeVariableNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTypeAnnotation"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "nestedTypeAnnotation"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nestedTypeAnnotationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableMapKeyType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "nonComparableMapKeyType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nonComparableMapKeyTypeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableSetElementType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "nonComparableSetElementType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.nonComparableSetElementTypeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "singleVariantUnion"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "singleVariantUnion"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.singleVariantUnionError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInForall"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeVariableShadowingInForall"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.typeVariableShadowingInForallError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedTypeVariable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTypeVariableError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "voidInNonBottomPosition"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "voidInNonBottomPosition"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.voidInNonBottomPositionError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeLambdaParameterNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.InvalidTypeLambdaParameterNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTypeLambdaParameterNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.invalidTypeSchemeVariableNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.InvalidTypeSchemeVariableNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.InvalidTypeSchemeVariableNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.literalTypeMismatchError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.LiteralTypeMismatchError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.LiteralTypeMismatchError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedType"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.literalType"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_expectedType"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.literalType"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_actualType"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "expectedType"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedType"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "actualType"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.LiteralTypeMismatchError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nestedTermAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTermAnnotationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.NestedTermAnnotationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NestedTermAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nestedTypeAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTypeAnnotationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.NestedTypeAnnotationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NestedTypeAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nonComparableMapKeyTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.NonComparableMapKeyTypeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keyType"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_keyType"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "keyType"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_keyType"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NonComparableMapKeyTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.nonComparableSetElementTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableSetElementTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.NonComparableSetElementTypeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "elementType"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_elementType"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "elementType"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_elementType"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.NonComparableSetElementTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.redundantWrapUnwrapError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.RedundantWrapUnwrapError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.RedundantWrapUnwrapError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_typeName"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.RedundantWrapUnwrapError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.selfApplicationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.SelfApplicationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.SelfApplicationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.SelfApplicationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.singleVariantUnionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.SingleVariantUnionError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.SingleVariantUnionError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_fieldName"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "fieldName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.SingleVariantUnionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.termVariableShadowingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TermVariableShadowingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.TermVariableShadowingError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.TermVariableShadowingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.typeVariableShadowingInForallError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.TypeVariableShadowingInForallError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.TypeVariableShadowingInForallError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.typeVariableShadowingInTypeLambdaError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.TypeVariableShadowingInTypeLambdaError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.TypeVariableShadowingInTypeLambdaError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedFieldError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedFieldError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UndefinedFieldError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_fieldName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_typeName"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "fieldName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "typeName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedFieldError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTermVariableError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTermVariableError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UndefinedTermVariableError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTermVariableError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UndefinedTypeVariableError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInBindingTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UndefinedTypeVariableInBindingTypeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableInBindingTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInLambdaDomainError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UndefinedTypeVariableInLambdaDomainError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableInLambdaDomainError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.undefinedTypeVariableInTypeApplicationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UndefinedTypeVariableInTypeApplicationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UndefinedTypeVariableInTypeApplicationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unexpectedTermVariantError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTermVariantError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UnexpectedTermVariantError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedVariant"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.termVariant"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_expectedVariant"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualTerm"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_actualTerm"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "expectedVariant"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedVariant"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "actualTerm"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualTerm"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnexpectedTermVariantError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unexpectedTypeVariantError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTypeVariantError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UnexpectedTypeVariantError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedVariant"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.variants.typeVariant"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_expectedVariant"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actualType"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_actualType"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "expectedVariant"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedVariant"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "actualType"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_actualType"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnexpectedTypeVariantError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unknownPrimitiveNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnknownPrimitiveNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UnknownPrimitiveNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnknownPrimitiveNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.unnecessaryIdentityApplicationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UnnecessaryIdentityApplicationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UnnecessaryIdentityApplicationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.untypedTermVariableError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.UntypedTermVariableError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.UntypedTermVariableError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "location"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.UntypedTermVariableError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.core.voidInNonBottomPositionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.core.VoidInNonBottomPositionError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.core.VoidInNonBottomPositionError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "location"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_location"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "location"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_location"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.core.VoidInNonBottomPositionError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs view
@@ -0,0 +1,1632 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.error.packaging++module Hydra.Sources.Decode.Error.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.error.packaging"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.error.packaging"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.packaging"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.packaging"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.util"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.conflictingModuleNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingModuleNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.ConflictingModuleNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "first"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_first"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "second"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_second"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "first"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_first"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "second"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_second"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.ConflictingModuleNameError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.conflictingVariantNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingVariantNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.ConflictingVariantNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_typeName"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variantName"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_variantName"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "conflictingName"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_conflictingName"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "moduleName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "typeName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeName"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "variantName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_variantName"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "conflictingName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_conflictingName"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.ConflictingVariantNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.definitionNotInModuleNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.DefinitionNotInModuleNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "moduleName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DefinitionNotInModuleNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.definitionsOutOfOrderError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.DefinitionsOutOfOrderError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "precedingName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_precedingName"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "followingName"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_followingName"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "moduleName"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "precedingName"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_precedingName"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "followingName"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_followingName"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DefinitionsOutOfOrderError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.duplicateDefinitionNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.DuplicateDefinitionNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "moduleName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DuplicateDefinitionNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.duplicateModuleNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateModuleNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.DuplicateModuleNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "moduleName"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.DuplicateModuleNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidDefinitionNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.InvalidDefinitionNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expectedConvention"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.util.caseConvention"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_expectedConvention"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "moduleName"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "name"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "expectedConvention"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_expectedConvention"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidDefinitionNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidModuleError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingVariantName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "conflictingVariantName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.conflictingVariantNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitionNotInModuleName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "definitionNotInModuleName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.definitionNotInModuleNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitionsOutOfOrder"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "definitionsOutOfOrder"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.definitionsOutOfOrderError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateDefinitionName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateDefinitionName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.duplicateDefinitionNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidDefinitionName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidDefinitionName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.invalidDefinitionNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidModuleNameConvention"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidModuleNameConvention"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.invalidModuleNameConventionError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "missingDocumentation"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "missingDocumentation"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.missingDocumentationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidModuleError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidModuleNameConventionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.InvalidModuleNameConventionError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "moduleName"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidModuleNameConventionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidPackageError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingModuleName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "conflictingModuleName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.conflictingModuleNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateModuleName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateModuleName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.duplicateModuleNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidModule"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidModule"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.invalidModuleError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidPackageName"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidPackageName"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.packaging.invalidPackageNameError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidPackageError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.invalidPackageNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageNameError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.InvalidPackageNameError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "packageName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_packageName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "packageName"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_packageName"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.InvalidPackageNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.error.packaging.missingDocumentationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.error.packaging.MissingDocumentationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.error.packaging.MissingDocumentationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_name"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "moduleName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.error.packaging.MissingDocumentationError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Errors.hs view
@@ -0,0 +1,2759 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.errors++module Hydra.Sources.Decode.Errors where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.errors"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.errors"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.errors"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.error.checking"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.error.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.variants"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.decodingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.DecodingError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.emptyListError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = Core.TypeUnit}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "t"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.EmptyListError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.error"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.Error"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "checking"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "checking"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.checkingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decoding"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "decoding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.decodingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateBinding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateBindingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "duplicateField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.duplicateFieldError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "extraction"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "extraction"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.extractionError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inference"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "inference"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.inferenceError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLiteral"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "invalidLiteral"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.invalidLiteralError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "other"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.otherError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "resolution"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "resolution"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.resolutionError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedFieldError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "undefinedTermVariable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.undefinedTermVariableError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "untypedTermVariable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.untypedTermVariableError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTermVariant"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unexpectedTermVariant"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unexpectedTermVariantError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTypeVariant"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unexpectedTypeVariant"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.core.unexpectedTypeVariantError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unification"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.Error"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unification"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.unificationError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.Error")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.extractionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.ExtractionError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyList"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "emptyList"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.emptyListError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "multipleBindings"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "multipleBindings"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.multipleBindingsError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "multipleFields"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "multipleFields"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.multipleFieldsError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noMatchingField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "noMatchingField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.noMatchingFieldError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchBinding"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "noSuchBinding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.noSuchBindingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notEnoughCases"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "notEnoughCases"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.notEnoughCasesError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedShape"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ExtractionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unexpectedShape"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.unexpectedShapeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.ExtractionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.inferenceError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.InferenceError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "checking"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "checking"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.error.checking.checkingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "other"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.otherInferenceError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unification"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.InferenceError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unification"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.unificationInferenceError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.InferenceError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.multipleBindingsError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.MultipleBindingsError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.MultipleBindingsError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.errors.MultipleBindingsError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "name"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.MultipleBindingsError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.multipleFieldsError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.MultipleFieldsError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.MultipleFieldsError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_fieldName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.errors.MultipleFieldsError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "fieldName"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.MultipleFieldsError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.noMatchingFieldError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.NoMatchingFieldError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.NoMatchingFieldError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "fieldName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_fieldName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "fieldName"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_fieldName"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NoMatchingFieldError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.noSuchBindingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchBindingError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.NoSuchBindingError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.errors.NoSuchBindingError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "name"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NoSuchBindingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.noSuchPrimitiveError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchPrimitiveError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.NoSuchPrimitiveError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "name"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NoSuchPrimitiveError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.notEnoughCasesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = Core.TypeUnit}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "t"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.NotEnoughCasesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.otherError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.OtherError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherError"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.OtherError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.otherInferenceError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.OtherInferenceError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.OtherInferenceError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_path"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_message"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "path"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "message"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.OtherInferenceError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.otherResolutionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.OtherResolutionError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.OtherResolutionError"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.OtherResolutionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.resolutionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.ResolutionError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchBinding"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "noSuchBinding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.noSuchBindingError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchPrimitive"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "noSuchPrimitive"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.noSuchPrimitiveError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noMatchingField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "noMatchingField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.noMatchingFieldError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "other"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.otherResolutionError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedShape"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.errors.ResolutionError"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unexpectedShape"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.errors.unexpectedShapeError")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.ResolutionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.unexpectedShapeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.UnexpectedShapeError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.UnexpectedShapeError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "expected"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "cx"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "raw"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "err"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "stripped"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                          Core.caseStatementCases = [+                                                            Core.CaseAlternative {+                                                              Core.caseAlternativeName = (Core.Name "literal"),+                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "v"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "string"),+                                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                          Core.lambdaParameter = (Core.Name "s"),+                                                                          Core.lambdaDomain = Nothing,+                                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_expected"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "actual"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_actual"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "expected"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_expected"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "actual"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_actual"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.UnexpectedShapeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.unificationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.UnificationError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "leftType"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_leftType"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "rightType"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_rightType"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_message"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.errors.UnificationError"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "leftType"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_leftType"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "rightType"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_rightType"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "message"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.UnificationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.errors.unificationInferenceError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.errors.UnificationInferenceError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.errors.UnificationInferenceError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_path"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "cause"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.errors.unificationError"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_cause"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "path"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "cause"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_cause"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.errors.UnificationInferenceError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Json/Model.hs view
@@ -0,0 +1,503 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.json.model++module Hydra.Sources.Decode.Json.Model where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.json.model"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.json.model"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.json.model"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.json.model.value"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.json.model.Value"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "array"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "array"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "boolean"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "boolean"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "b"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "null"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "null"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "number"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "number"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected decimal literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "decimal"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "d"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "d"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "object"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "object"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodePair")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "cx"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "raw"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "err"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "stripped"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "literal"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "v"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "string"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "s"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.json.model.value"))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.json.model.Value"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "string"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.json.model.Value")))]))}))})]}
+ src/main/haskell/Hydra/Sources/Decode/Packaging.hs view
@@ -0,0 +1,2563 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.packaging++module Hydra.Sources.Decode.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.packaging"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.packaging"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.packaging"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.typing"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.definition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Definition"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "term"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.packaging.termDefinition")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "type"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.packaging.typeDefinition")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primitive"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.Definition"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "primitive"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.packaging.primitiveDefinition")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Definition")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.definitionReference"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.DefinitionReference"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "type"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "term"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primitive"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "primitive"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.DefinitionReference")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.entityMetadata"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.EntityMetadata"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "cx"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "raw"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "err"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "stripped"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                            Core.caseStatementCases = [+                                                              Core.CaseAlternative {+                                                                Core.caseAlternativeName = (Core.Name "literal"),+                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "v"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                      Core.caseStatementCases = [+                                                                        Core.CaseAlternative {+                                                                          Core.caseAlternativeName = (Core.Name "string"),+                                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                            Core.lambdaParameter = (Core.Name "s"),+                                                                            Core.lambdaDomain = Nothing,+                                                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_description"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "comments"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "cx"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "raw"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "err"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "stripped"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                Core.caseStatementCases = [+                                                                  Core.CaseAlternative {+                                                                    Core.caseAlternativeName = (Core.Name "literal"),+                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "v"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "string"),+                                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                Core.lambdaParameter = (Core.Name "s"),+                                                                                Core.lambdaDomain = Nothing,+                                                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_comments"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "seeAlso"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityReference"))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_seeAlso"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "lifecycle"))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.lifecycleInfo"))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_lifecycle"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "description"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "comments"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_comments"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "seeAlso"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_seeAlso"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "lifecycle"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_lifecycle"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.EntityMetadata")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.entityReference"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.EntityReference"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "package"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "package"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "module"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "module"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definition"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.EntityReference"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "definition"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.packaging.definitionReference")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.EntityReference")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.lifecycleInfo"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.LifecycleInfo"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.LifecycleInfo"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "availableSince"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.version"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_availableSince"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "deprecatedSince"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.version"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_deprecatedSince"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "availableSince"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_availableSince"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "deprecatedSince"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_deprecatedSince"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.LifecycleInfo")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.module"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Module"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.Module"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_metadata"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "dependencies"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleDependency"))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_dependencies"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "definitions"))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.definition"))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_definitions"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.packaging.Module"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "name"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "metadata"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "dependencies"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_dependencies"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "definitions"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_definitions"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Module")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.moduleDependency"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleDependency"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.ModuleDependency"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "module"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_module"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "package"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_package"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "module"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_module"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "package"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_package"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.ModuleDependency")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.moduleName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.packaging.ModuleName"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.ModuleName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.package"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Package"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.Package"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_metadata"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "dependencies"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageDependency"))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_dependencies"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "modules"))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.module"))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_modules"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.packaging.Package"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "name"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "metadata"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "dependencies"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_dependencies"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "modules"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_modules"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Package")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.packageDependency"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.PackageDependency"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.PackageDependency"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.packageName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "version"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.versionSpecifier"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_version"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.packaging.PackageDependency"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "version"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_version"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.PackageDependency")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.packageName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.PackageName"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.packaging.PackageName"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.PackageName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.primitiveDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.PrimitiveDefinition"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.PrimitiveDefinition"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_metadata"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "signature"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.termSignature"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_signature"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "isPure"))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "cx"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "raw"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "err"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "stripped"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                      Core.caseStatementCases = [+                                                                        Core.CaseAlternative {+                                                                          Core.caseAlternativeName = (Core.Name "literal"),+                                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                            Core.lambdaParameter = (Core.Name "v"),+                                                                            Core.lambdaDomain = Nothing,+                                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                                Core.caseStatementCases = [+                                                                                  Core.CaseAlternative {+                                                                                    Core.caseAlternativeName = (Core.Name "boolean"),+                                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                      Core.lambdaParameter = (Core.Name "b"),+                                                                                      Core.lambdaDomain = Nothing,+                                                                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_isPure"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "isTotal"))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "cx"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "raw"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "err"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "stripped"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "literal"),+                                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                Core.lambdaParameter = (Core.Name "v"),+                                                                                Core.lambdaDomain = Nothing,+                                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                                    Core.caseStatementCases = [+                                                                                      Core.CaseAlternative {+                                                                                        Core.caseAlternativeName = (Core.Name "boolean"),+                                                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                          Core.lambdaParameter = (Core.Name "b"),+                                                                                          Core.lambdaDomain = Nothing,+                                                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "field_isTotal"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "defaultImplementation"))})),+                                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))}))})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "field_defaultImplementation"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                            Core.recordTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+                                                            Core.recordFields = [+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "name"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "metadata"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "signature"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_signature"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "isPure"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_isPure"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "isTotal"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_isTotal"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "defaultImplementation"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_defaultImplementation"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.PrimitiveDefinition")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.termDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.TermDefinition"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.TermDefinition"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_metadata"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "signature"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.termSignature"))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_signature"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_body"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.packaging.TermDefinition"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "name"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "metadata"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "signature"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_signature"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "body"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.TermDefinition")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.typeDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.TypeDefinition"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.packaging.TypeDefinition"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "metadata"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.entityMetadata"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_metadata"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeScheme"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_body"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "name"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "metadata"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_metadata"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "body"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.TypeDefinition")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.version"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.Version"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.packaging.Version"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.Version")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.packaging.versionSpecifier"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.packaging.VersionSpecifier"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "any"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.packaging.VersionSpecifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "any"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.packaging.VersionSpecifier")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Parsing.hs view
@@ -0,0 +1,599 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.parsing++module Hydra.Sources.Decode.Parsing where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.parsing"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.parsing"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.parsing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.parsing.parseError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.parsing.ParseError"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.parsing.ParseError"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "message"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "cx"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "raw"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "err"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "stripped"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                          Core.caseStatementCases = [+                                                            Core.CaseAlternative {+                                                              Core.caseAlternativeName = (Core.Name "literal"),+                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "v"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "string"),+                                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                          Core.lambdaParameter = (Core.Name "s"),+                                                                          Core.lambdaDomain = Nothing,+                                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_message"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "remainder"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_remainder"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "message"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_message"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "remainder"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_remainder"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.parsing.ParseError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.parsing.parseResult"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.parsing.ParseResult")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "inject"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "inj"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "field"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermProject (Core.Projection {+                                            Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                            Core.projectionFieldName = (Core.Name "field")})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                        Core.bindingTypeScheme = Nothing},+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fname"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermProject (Core.Projection {+                                            Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                            Core.projectionFieldName = (Core.Name "name")})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                        Core.bindingTypeScheme = Nothing},+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fterm"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermProject (Core.Projection {+                                            Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                            Core.projectionFieldName = (Core.Name "term")})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                        Core.bindingTypeScheme = Nothing},+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "variantMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermPair (+                                              Core.TermWrap (Core.WrappedTerm {+                                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "success"))}),+                                              (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "input"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "t"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                        Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"),+                                                        Core.injectionField = Core.Field {+                                                          Core.fieldName = (Core.Name "success"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseSuccess")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                            (Core.TermPair (+                                              Core.TermWrap (Core.WrappedTerm {+                                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "failure"))}),+                                              (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "input"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "t"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                        Core.injectionTypeName = (Core.Name "hydra.parsing.ParseResult"),+                                                        Core.injectionField = Core.Field {+                                                          Core.fieldName = (Core.Name "failure"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.parsing.parseError")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                        Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                          Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                            Core.applicationArgument = (Core.TermList [+                                              Core.TermLiteral (Core.LiteralString "no such field "),+                                              (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                              (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "f"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.parsing.ParseResult")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.parsing.parseSuccess"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.parsing.ParseSuccess")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.parsing.ParseSuccess"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "value"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_value"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "remainder"))})),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "cx"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "raw"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "err"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "stripped"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                Core.caseStatementCases = [+                                                                  Core.CaseAlternative {+                                                                    Core.caseAlternativeName = (Core.Name "literal"),+                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "v"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "string"),+                                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                Core.lambdaParameter = (Core.Name "s"),+                                                                                Core.lambdaDomain = Nothing,+                                                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_remainder"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                              Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+                                              Core.recordFields = [+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "value"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_value"))},+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "remainder"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_remainder"))}]}))))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.parsing.ParseSuccess")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Paths.hs view
@@ -0,0 +1,2771 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.paths++module Hydra.Sources.Decode.Paths where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.paths"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.paths"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermEdge"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermEdge"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.paths.SubtermEdge"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "source"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermNode"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_source"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermPath"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_path"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "target"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermNode"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_target"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.paths.SubtermEdge"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "source"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_source"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "path"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "target"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_target"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermEdge")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermGraph"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermGraph"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.paths.SubtermGraph"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "nodes"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermNode"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_nodes"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "edges"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermEdge"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_edges"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.paths.SubtermGraph"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "nodes"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_nodes"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "edges"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_edges"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermGraph")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermNode"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermNode"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.paths.SubtermNode"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "label"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_label"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "id"))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_id"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.paths.SubtermNode"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "name"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "label"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_label"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "id"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_id"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermNode")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermPath"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermPath"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtermPath"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermStep"))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermPath")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtermStep"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtermStep"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotatedBody"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "annotatedBody"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationFunction"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "applicationFunction"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationArgument"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "applicationArgument"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambdaBody"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "lambdaBody"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionCasesDefault"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unionCasesDefault"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionCasesBranch"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unionCasesBranch"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "letBody"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "letBody"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "letBinding"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "letBinding"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "listElement"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "listElement"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapKey"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "mapKey"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapValue"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "mapValue"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optionalTerm"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "optionalTerm"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "productTerm"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "productTerm"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "recordField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "recordField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "setElement"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "setElement"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "sumTerm"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "sumTerm"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambdaBody"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeLambdaBody"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplicationTerm"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeApplicationTerm"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "injectionTerm"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "injectionTerm"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrappedTerm"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtermStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "wrappedTerm"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtermStep")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeEdge"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeEdge"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.paths.SubtypeEdge"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "source"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeNode"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_source"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypePath"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_path"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "target"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeNode"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_target"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "source"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_source"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "path"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "target"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_target"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeEdge")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeGraph"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeGraph"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.paths.SubtypeGraph"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "nodes"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeNode"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_nodes"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "edges"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeEdge"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_edges"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "nodes"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_nodes"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "edges"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_edges"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeGraph")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeNode"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeNode"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.paths.SubtypeNode"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "label"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_label"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "id"))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_id"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.paths.SubtypeNode"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "name"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "label"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_label"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "id"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_id"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeNode")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypePath"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypePath"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.paths.SubtypePath"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtypeStep"))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypePath")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.paths.subtypeStep"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeStep"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotatedBody"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "annotatedBody"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationFunction"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "applicationFunction"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationArgument"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "applicationArgument"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "eitherLeft"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "eitherLeft"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "eitherRight"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "eitherRight"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forallBody"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "forallBody"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "functionDomain"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "functionDomain"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "functionCodomain"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "functionCodomain"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "listElement"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "listElement"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapKeys"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "mapKeys"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapValues"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "mapValues"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optionalElement"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "optionalElement"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pairFirst"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pairFirst"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pairSecond"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pairSecond"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "recordField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "recordField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "setElement"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "setElement"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionField"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unionField"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.name")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrappedType"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.paths.SubtypeStep"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "wrappedType"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.paths.SubtypeStep")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Query.hs view
@@ -0,0 +1,2719 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.query++module Hydra.Sources.Decode.Query where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.query"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.query"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.query"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.comparisonConstraint"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.ComparisonConstraint"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "equal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "equal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notEqual"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "notEqual"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThan"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "lessThan"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThan"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "greaterThan"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThanOrEqual"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "lessThanOrEqual"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThanOrEqual"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "greaterThanOrEqual"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.ComparisonConstraint")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.edge"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Edge"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.Edge"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_type"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "out"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_out"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "in"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_in"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.query.Edge"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "type"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "out"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_out"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "in"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_in"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Edge")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.graphPattern"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.GraphPattern"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.GraphPattern"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "graph"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_graph"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "patterns"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_patterns"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.query.GraphPattern"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "graph"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_graph"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "patterns"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_patterns"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.GraphPattern")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.node"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Node"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Node"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "term"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.term")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Node"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "variable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.variable")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wildcard"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Node"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "wildcard"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Node")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.path"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Path"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "step"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Path"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "step"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.step")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "regex"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Path"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "regex"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.regexSequence")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inverse"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Path"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "inverse"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.path")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Path")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.pathEquation"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.PathEquation"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.PathEquation"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_left"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_right"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.query.PathEquation"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "left"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "right"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.PathEquation")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.pattern"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Pattern"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "triple"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "triple"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.triplePattern")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "negation"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "negation"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.pattern")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conjunction"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "conjunction"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "disjunction"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "disjunction"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "graph"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Pattern"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "graph"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.graphPattern")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Pattern")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.patternImplication"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.PatternImplication"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.PatternImplication"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "antecedent"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_antecedent"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "consequent"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_consequent"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.query.PatternImplication"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "antecedent"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_antecedent"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "consequent"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_consequent"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.PatternImplication")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.query"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Query"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.Query"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "variables"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.variable"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_variables"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "patterns"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.pattern"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_patterns"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.query.Query"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "variables"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_variables"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "patterns"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_patterns"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Query")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.range"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Range"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.Range"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "min"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "cx"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "raw"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "err"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "stripped"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                          Core.caseStatementCases = [+                                                            Core.CaseAlternative {+                                                              Core.caseAlternativeName = (Core.Name "literal"),+                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "v"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "integer"),+                                                                        Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "int32"),+                                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                Core.lambdaParameter = (Core.Name "i"),+                                                                                Core.lambdaDomain = Nothing,+                                                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_min"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "max"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "integer"),+                                                                            Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                              Core.caseStatementCases = [+                                                                                Core.CaseAlternative {+                                                                                  Core.caseAlternativeName = (Core.Name "int32"),+                                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                    Core.lambdaParameter = (Core.Name "i"),+                                                                                    Core.lambdaDomain = Nothing,+                                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_max"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.query.Range"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "min"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_min"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "max"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_max"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Range")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.regexQuantifier"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.RegexQuantifier"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "one"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "one"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "zeroOrOne"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "zeroOrOne"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "zeroOrMore"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "zeroOrMore"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "oneOrMore"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "oneOrMore"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "exactly"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "exactly"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "atLeast"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "atLeast"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "range"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.RegexQuantifier"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "range"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.range")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.RegexQuantifier")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.regexSequence"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.RegexSequence"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.RegexSequence"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "path"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_path"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "quantifier"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.regexQuantifier"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_quantifier"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.query.RegexSequence"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "path"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_path"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "quantifier"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_quantifier"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.RegexSequence")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.step"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Step"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "edge"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Step"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "edge"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.edge")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Step"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "project"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.projection")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "compare"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.query.Step"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "compare"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.query.comparisonConstraint")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Step")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.triplePattern"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.TriplePattern"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.query.TriplePattern"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "subject"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.node"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_subject"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "predicate"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.path"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_predicate"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "object"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.query.node"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_object"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.query.TriplePattern"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "subject"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_subject"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "predicate"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_predicate"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "object"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_object"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.TriplePattern")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.query.variable"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.query.Variable"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.query.Variable"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.query.Variable")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Relational.hs view
@@ -0,0 +1,1087 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.relational++module Hydra.Sources.Decode.Relational where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.relational"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.relational"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.relational"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.columnName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.ColumnName"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.relational.ColumnName"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.ColumnName")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.columnSchema"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "t"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "t"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.ColumnSchema")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "t"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.relational.ColumnSchema"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_name"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domain"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "t"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_domain"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                              Core.recordTypeName = (Core.Name "hydra.relational.ColumnSchema"),+                                              Core.recordFields = [+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "name"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "domain"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_domain"))}]}))))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.ColumnSchema")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.foreignKey"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.ForeignKey"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.relational.ForeignKey"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foreignRelation"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.relationName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_foreignRelation"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "keys"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_keys"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.relational.ForeignKey"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "foreignRelation"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_foreignRelation"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "keys"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_keys"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.ForeignKey")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.primaryKey"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.PrimaryKey"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.relational.PrimaryKey"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.PrimaryKey")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relation"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Relation")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "wrap"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "b"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                          Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relation"),+                                          Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.row")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                          Core.projectionFieldName = (Core.Name "body")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.Relation")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relationName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.relational.RelationName"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.relational.RelationName"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.RelationName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relationSchema"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "t"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "t"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.RelationSchema")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "t"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.relational.RelationSchema"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.relationName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_name"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "columns"))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.relational.columnSchema")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_columns"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "primaryKeys"))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.primaryKey"))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "field_primaryKeys"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "foreignKeys"))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.foreignKey"))}))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "field_foreignKeys"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                      Core.recordTypeName = (Core.Name "hydra.relational.RelationSchema"),+                                                      Core.recordFields = [+                                                        Core.Field {+                                                          Core.fieldName = (Core.Name "name"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                        Core.Field {+                                                          Core.fieldName = (Core.Name "columns"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "field_columns"))},+                                                        Core.Field {+                                                          Core.fieldName = (Core.Name "primaryKeys"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "field_primaryKeys"))},+                                                        Core.Field {+                                                          Core.fieldName = (Core.Name "foreignKeys"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "field_foreignKeys"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.RelationSchema")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.relationship"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = [+                  Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Relationship")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "wrap"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "b"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                          Core.wrappedTermTypeName = (Core.Name "hydra.relational.Relationship"),+                                          Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                          Core.projectionFieldName = (Core.Name "body")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.Relationship")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.relational.row"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Row")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "wrap"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "b"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                          Core.wrappedTermTypeName = (Core.Name "hydra.relational.Row"),+                                          Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                          Core.projectionFieldName = (Core.Name "body")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.relational.Row")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Tabular.hs view
@@ -0,0 +1,614 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.tabular++module Hydra.Sources.Decode.Tabular where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.tabular"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.tabular"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.tabular"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.relational"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.columnType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.tabular.ColumnType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.tabular.ColumnType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.columnName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_type"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.tabular.ColumnType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "type"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.ColumnType")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.dataRow"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.tabular.DataRow")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "wrap"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "b"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                          Core.wrappedTermTypeName = (Core.Name "hydra.tabular.DataRow"),+                                          Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                          Core.projectionFieldName = (Core.Name "body")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.DataRow")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.headerRow"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.tabular.HeaderRow"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.tabular.HeaderRow"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "cx"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "raw"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "err"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "stripped"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                      Core.caseStatementCases = [+                                                        Core.CaseAlternative {+                                                          Core.caseAlternativeName = (Core.Name "literal"),+                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "v"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                Core.caseStatementCases = [+                                                                  Core.CaseAlternative {+                                                                    Core.caseAlternativeName = (Core.Name "string"),+                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "s"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.HeaderRow")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.table"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "v"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.tabular.Table")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.tabular.Table"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "header"))})),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.tabular.headerRow"))}))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_header"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "data"))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.tabular.dataRow")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_data"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                              Core.recordTypeName = (Core.Name "hydra.tabular.Table"),+                                              Core.recordFields = [+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "header"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_header"))},+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "data"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_data"))}]}))))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.Table")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.tabular.tableType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.tabular.TableType"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.tabular.TableType"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.relational.relationName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "columns"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.tabular.columnType"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_columns"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.tabular.TableType"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "columns"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_columns"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.tabular.TableType")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Testing.hs view
@@ -0,0 +1,164 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.testing++module Hydra.Sources.Decode.Testing where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.testing"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.testing"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.testing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.testing.tag"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.testing.Tag"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.testing.Tag"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.testing.Tag")))]))}))})]}
+ src/main/haskell/Hydra/Sources/Decode/Topology.hs view
@@ -0,0 +1,517 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.topology++module Hydra.Sources.Decode.Topology where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.topology"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.topology"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.topology"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.topology.graph"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.topology.Vertex")),+                  Core.mapTypeValues = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.topology.Vertex")))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermApplication (Core.Application {+              Core.applicationFunction = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))})),+              Core.applicationArgument = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.topology.Graph")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.topology.tarjanState"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.topology.TarjanState"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.topology.TarjanState"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "counter"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "cx"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "raw"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "err"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "stripped"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                          Core.caseStatementCases = [+                                                            Core.CaseAlternative {+                                                              Core.caseAlternativeName = (Core.Name "literal"),+                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "v"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "integer"),+                                                                        Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "int32"),+                                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                Core.lambdaParameter = (Core.Name "i"),+                                                                                Core.lambdaDomain = Nothing,+                                                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_counter"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "indices"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))})),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "cx"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "raw"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "err"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "stripped"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                Core.caseStatementCases = [+                                                                  Core.CaseAlternative {+                                                                    Core.caseAlternativeName = (Core.Name "literal"),+                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "v"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "integer"),+                                                                              Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                Core.caseStatementCases = [+                                                                                  Core.CaseAlternative {+                                                                                    Core.caseAlternativeName = (Core.Name "int32"),+                                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                      Core.lambdaParameter = (Core.Name "i"),+                                                                                      Core.lambdaDomain = Nothing,+                                                                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_indices"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "lowLinks"))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))})),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "cx"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "raw"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "err"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                          Core.lambdaParameter = (Core.Name "v"),+                                                                          Core.lambdaDomain = Nothing,+                                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                              Core.caseStatementCases = [+                                                                                Core.CaseAlternative {+                                                                                  Core.caseAlternativeName = (Core.Name "integer"),+                                                                                  Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                    Core.caseStatementCases = [+                                                                                      Core.CaseAlternative {+                                                                                        Core.caseAlternativeName = (Core.Name "int32"),+                                                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                          Core.lambdaParameter = (Core.Name "i"),+                                                                                          Core.lambdaDomain = Nothing,+                                                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_lowLinks"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "stack"))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_stack"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "onStack"))})),+                                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "field_onStack"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "sccs"))})),+                                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.topology.vertex"))}))}))})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "field_sccs"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                            Core.recordTypeName = (Core.Name "hydra.topology.TarjanState"),+                                                            Core.recordFields = [+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "counter"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_counter"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "indices"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_indices"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "lowLinks"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_lowLinks"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "stack"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_stack"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "onStack"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_onStack"))},+                                                              Core.Field {+                                                                Core.fieldName = (Core.Name "sccs"),+                                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_sccs"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.topology.TarjanState")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.topology.vertex"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.core.Literal"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "literal"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "v"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                    Core.caseStatementCases = [+                                      Core.CaseAlternative {+                                        Core.caseAlternativeName = (Core.Name "integer"),+                                        Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                          Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                          Core.caseStatementCases = [+                                            Core.CaseAlternative {+                                              Core.caseAlternativeName = (Core.Name "int32"),+                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "i"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.topology.Vertex")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Typed.hs view
@@ -0,0 +1,391 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.typed++module Hydra.Sources.Decode.Typed where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.typed"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.typed"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typed"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typed.typedBinding"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedBinding")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typed.TypedBinding"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_name"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.typed.typedTerm")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "a"))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_term"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                              Core.recordTypeName = (Core.Name "hydra.typed.TypedBinding"),+                                              Core.recordFields = [+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "name"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "term"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}]}))))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typed.TypedBinding")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typed.typedTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "wrap"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "b"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                          Core.wrappedTermTypeName = (Core.Name "hydra.typed.TypedTerm"),+                                          Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.core.term")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                          Core.projectionFieldName = (Core.Name "body")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typed.TypedTerm")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typed.typedTermDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "a"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTermDefinition")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typed.TypedTermDefinition"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_name"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.decode.typed.typedTerm")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "a"))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_term"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                              Core.recordTypeName = (Core.Name "hydra.typed.TypedTermDefinition"),+                                              Core.recordFields = [+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "name"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "term"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))}]}))))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typed.TypedTermDefinition")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Typing.hs view
@@ -0,0 +1,1709 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.typing++module Hydra.Sources.Decode.Typing where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.typing"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.typing"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.paths"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.functionStructure"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "env"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "env"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typing.FunctionStructure")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "env"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "env"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.FunctionStructure"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeParams"))})),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_typeParams"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "params"))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_params"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "bindings"))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.binding"))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "field_bindings"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                            Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "body"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "field_body"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "domains"))})),+                                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "field_domains"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "codomain"))})),+                                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))}))})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "field_codomain"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                                        Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "environment"))})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "env"))})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "field_environment"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                                  Core.recordTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                                                  Core.recordFields = [+                                                                    Core.Field {+                                                                      Core.fieldName = (Core.Name "typeParams"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeParams"))},+                                                                    Core.Field {+                                                                      Core.fieldName = (Core.Name "params"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "field_params"))},+                                                                    Core.Field {+                                                                      Core.fieldName = (Core.Name "bindings"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "field_bindings"))},+                                                                    Core.Field {+                                                                      Core.fieldName = (Core.Name "body"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "field_body"))},+                                                                    Core.Field {+                                                                      Core.fieldName = (Core.Name "domains"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "field_domains"))},+                                                                    Core.Field {+                                                                      Core.fieldName = (Core.Name "codomain"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "field_codomain"))},+                                                                    Core.Field {+                                                                      Core.fieldName = (Core.Name "environment"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "field_environment"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.FunctionStructure")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.inferenceContext"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.InferenceContext"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "freshTypeVariableCount"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "cx"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "raw"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "err"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "stripped"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                          Core.caseStatementCases = [+                                                            Core.CaseAlternative {+                                                              Core.caseAlternativeName = (Core.Name "literal"),+                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "v"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "integer"),+                                                                        Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "int32"),+                                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                Core.lambdaParameter = (Core.Name "i"),+                                                                                Core.lambdaDomain = Nothing,+                                                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_freshTypeVariableCount"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "trace"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.paths.subtermStep"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_trace"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.typing.InferenceContext"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "freshTypeVariableCount"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_freshTypeVariableCount"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "trace"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_trace"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.InferenceContext")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.inferenceResult"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.InferenceResult"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.InferenceResult"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "term"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_term"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_type"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "subst"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.typeSubst"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_subst"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "classConstraints"))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeVariableConstraints"))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_classConstraints"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "context"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.inferenceContext"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "field_context"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                        Core.recordTypeName = (Core.Name "hydra.typing.InferenceResult"),+                                                        Core.recordFields = [+                                                          Core.Field {+                                                            Core.fieldName = (Core.Name "term"),+                                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_term"))},+                                                          Core.Field {+                                                            Core.fieldName = (Core.Name "type"),+                                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},+                                                          Core.Field {+                                                            Core.fieldName = (Core.Name "subst"),+                                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_subst"))},+                                                          Core.Field {+                                                            Core.fieldName = (Core.Name "classConstraints"),+                                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_classConstraints"))},+                                                          Core.Field {+                                                            Core.fieldName = (Core.Name "context"),+                                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_context"))}]}))))}))}))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.InferenceResult")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.parameter"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.Parameter"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.Parameter"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "cx"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "raw"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "err"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "stripped"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                Core.caseStatementCases = [+                                                                  Core.CaseAlternative {+                                                                    Core.caseAlternativeName = (Core.Name "literal"),+                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                      Core.lambdaParameter = (Core.Name "v"),+                                                                      Core.lambdaDomain = Nothing,+                                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                          Core.caseStatementCases = [+                                                                            Core.CaseAlternative {+                                                                              Core.caseAlternativeName = (Core.Name "string"),+                                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                Core.lambdaParameter = (Core.Name "s"),+                                                                                Core.lambdaDomain = Nothing,+                                                                                Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_description"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_type"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "isLazy"))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "cx"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "raw"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "err"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "stripped"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                      Core.caseStatementCases = [+                                                                        Core.CaseAlternative {+                                                                          Core.caseAlternativeName = (Core.Name "literal"),+                                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                            Core.lambdaParameter = (Core.Name "v"),+                                                                            Core.lambdaDomain = Nothing,+                                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected boolean literal"))}))))),+                                                                                Core.caseStatementCases = [+                                                                                  Core.CaseAlternative {+                                                                                    Core.caseAlternativeName = (Core.Name "boolean"),+                                                                                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                      Core.lambdaParameter = (Core.Name "b"),+                                                                                      Core.lambdaDomain = Nothing,+                                                                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "b"))))}))}]})),+                                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_isLazy"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.typing.Parameter"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "name"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "description"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "type"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "isLazy"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_isLazy"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.Parameter")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.result"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.Result"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.Result"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "cx"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "raw"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "err"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "stripped"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                            Core.caseStatementCases = [+                                                              Core.CaseAlternative {+                                                                Core.caseAlternativeName = (Core.Name "literal"),+                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "v"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                      Core.caseStatementCases = [+                                                                        Core.CaseAlternative {+                                                                          Core.caseAlternativeName = (Core.Name "string"),+                                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                            Core.lambdaParameter = (Core.Name "s"),+                                                                            Core.lambdaDomain = Nothing,+                                                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_description"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "type"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_type"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.typing.Result"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "description"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "type"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_type"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.Result")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.termSignature"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TermSignature"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.TermSignature"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "typeParameters"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.typeParameter"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_typeParameters"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "parameters"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.parameter"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_parameters"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "result"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.typing.result"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_result"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.typing.TermSignature"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "typeParameters"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_typeParameters"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "parameters"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_parameters"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "result"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_result"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TermSignature")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.termSubst"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TermSubst"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.typing.TermSubst"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.term"))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TermSubst")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeClass"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeClass"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.TypeClass"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "description"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "cx"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "raw"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "err"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "stripped"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                          Core.caseStatementCases = [+                                                            Core.CaseAlternative {+                                                              Core.caseAlternativeName = (Core.Name "literal"),+                                                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "v"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                    Core.caseStatementCases = [+                                                                      Core.CaseAlternative {+                                                                        Core.caseAlternativeName = (Core.Name "string"),+                                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                          Core.lambdaParameter = (Core.Name "s"),+                                                                          Core.lambdaDomain = Nothing,+                                                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_description"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                        Core.recordTypeName = (Core.Name "hydra.typing.TypeClass"),+                                        Core.recordFields = [+                                          Core.Field {+                                            Core.fieldName = (Core.Name "description"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "field_description"))}]}))))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeClass")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeConstraint"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeConstraint"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.TypeConstraint"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "left"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_left"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "right"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_right"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "comment"))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "string"),+                                                                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                  Core.lambdaParameter = (Core.Name "s"),+                                                                                  Core.lambdaDomain = Nothing,+                                                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_comment"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                Core.recordTypeName = (Core.Name "hydra.typing.TypeConstraint"),+                                                Core.recordFields = [+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "left"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_left"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "right"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_right"))},+                                                  Core.Field {+                                                    Core.fieldName = (Core.Name "comment"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "field_comment"))}]}))))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeConstraint")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeParameter"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeParameter"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.typing.TypeParameter"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_name"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "constraints"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.typeClassConstraint"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_constraints"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.typing.TypeParameter"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "name"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_name"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "constraints"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_constraints"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeParameter")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.typing.typeSubst"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.typing.TypeSubst"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.typing.TypeSubst"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.type"))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.typing.TypeSubst")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Util.hs view
@@ -0,0 +1,1147 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.util++module Hydra.Sources.Decode.Util where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.util"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.util"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.packaging"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.util.caseConvention"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "camel"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "camel"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pascal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pascal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lowerSnake"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "lowerSnake"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "upperSnake"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "upperSnake"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.CaseConvention")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.util.comparison"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.Comparison"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThan"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "lessThan"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "equalTo"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "equalTo"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThan"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.Comparison"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "greaterThan"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.Comparison")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.util.fileExtension"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.FileExtension"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected wrapped type"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "wrap"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "wrappedTerm"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "b"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.util.FileExtension"),+                                        Core.wrappedTermBody = (Core.TermVariable (Core.Name "b"))}))}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "cx"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "raw"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "err"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                Core.lambdaParameter = (Core.Name "stripped"),+                                                Core.lambdaDomain = Nothing,+                                                Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                    Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                      Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                    Core.caseStatementCases = [+                                                      Core.CaseAlternative {+                                                        Core.caseAlternativeName = (Core.Name "literal"),+                                                        Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "v"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "string"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "s"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "wrappedTerm"))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.FileExtension")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.util.moduleNames"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "n"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "n"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.ModuleNames")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "n"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "n"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.util.ModuleNames"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "focus"))})),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodePair")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "n"))}))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_focus"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "mapping"))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMap")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "n"))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_mapping"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                              Core.recordTypeName = (Core.Name "hydra.util.ModuleNames"),+                                              Core.recordFields = [+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "focus"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_focus"))},+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "mapping"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_mapping"))}]}))))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.ModuleNames")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.util.precision"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.Precision"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "arbitrary"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.Precision"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "arbitrary"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bits"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.util.Precision"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "bits"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.Precision")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.util.qualifiedName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.util.QualifiedName"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.util.QualifiedName"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "moduleName"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeMaybe")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.packaging.moduleName"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_moduleName"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "local"))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "cx"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "raw"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "err"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "stripped"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                              Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                              Core.caseStatementCases = [+                                                                Core.CaseAlternative {+                                                                  Core.caseAlternativeName = (Core.Name "literal"),+                                                                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "v"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                      Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                        Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                        Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                          Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected string literal"))}))))),+                                                                        Core.caseStatementCases = [+                                                                          Core.CaseAlternative {+                                                                            Core.caseAlternativeName = (Core.Name "string"),+                                                                            Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                              Core.lambdaParameter = (Core.Name "s"),+                                                                              Core.lambdaDomain = Nothing,+                                                                              Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "s"))))}))}]})),+                                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_local"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                            Core.recordTypeName = (Core.Name "hydra.util.QualifiedName"),+                                            Core.recordFields = [+                                              Core.Field {+                                                Core.fieldName = (Core.Name "moduleName"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_moduleName"))},+                                              Core.Field {+                                                Core.fieldName = (Core.Name "local"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "field_local"))}]}))))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Decoder for hydra.util.QualifiedName")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Validation.hs view
@@ -0,0 +1,433 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.validation++module Hydra.Sources.Decode.Validation where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.validation"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.validation"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.validation"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.error.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.validation.validationProfile"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.validation.ValidationProfile"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.validation.ValidationProfile"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "record"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "record"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fieldMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                              Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "errorRules"))})),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "field_errorRules"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                  Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "warningRules"))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeSet")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.decode.core.name"))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                          Core.lambdaParameter = (Core.Name "field_warningRules"),+                                          Core.lambdaDomain = Nothing,+                                          Core.lambdaBody = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "maxErrors"))})),+                                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "raw"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                              Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                Core.lambdaParameter = (Core.Name "err"),+                                                                Core.lambdaDomain = Nothing,+                                                                Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "stripped"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                  Core.caseStatementCases = [+                                                                    Core.CaseAlternative {+                                                                      Core.caseAlternativeName = (Core.Name "literal"),+                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                        Core.lambdaParameter = (Core.Name "v"),+                                                                        Core.lambdaDomain = Nothing,+                                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                            Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                            Core.caseStatementCases = [+                                                                              Core.CaseAlternative {+                                                                                Core.caseAlternativeName = (Core.Name "integer"),+                                                                                Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                  Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                  Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                    Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                  Core.caseStatementCases = [+                                                                                    Core.CaseAlternative {+                                                                                      Core.caseAlternativeName = (Core.Name "int32"),+                                                                                      Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                        Core.lambdaParameter = (Core.Name "i"),+                                                                                        Core.lambdaDomain = Nothing,+                                                                                        Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "field_maxErrors"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                          Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "maxWarnings"))})),+                                                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                          Core.lambdaParameter = (Core.Name "cx"),+                                                          Core.lambdaDomain = Nothing,+                                                          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                            Core.lambdaParameter = (Core.Name "raw"),+                                                            Core.lambdaDomain = Nothing,+                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                    Core.lambdaParameter = (Core.Name "err"),+                                                                    Core.lambdaDomain = Nothing,+                                                                    Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                                  Core.lambdaParameter = (Core.Name "stripped"),+                                                                  Core.lambdaDomain = Nothing,+                                                                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                    Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected literal"))}))))),+                                                                      Core.caseStatementCases = [+                                                                        Core.CaseAlternative {+                                                                          Core.caseAlternativeName = (Core.Name "literal"),+                                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                            Core.lambdaParameter = (Core.Name "v"),+                                                                            Core.lambdaDomain = Nothing,+                                                                            Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                                              Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                                                                                Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+                                                                                Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                  Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 literal"))}))))),+                                                                                Core.caseStatementCases = [+                                                                                  Core.CaseAlternative {+                                                                                    Core.caseAlternativeName = (Core.Name "integer"),+                                                                                    Core.caseAlternativeHandler = (Core.TermCases (Core.CaseStatement {+                                                                                      Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                                                      Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                                                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                                                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected int32 value"))}))))),+                                                                                      Core.caseStatementCases = [+                                                                                        Core.CaseAlternative {+                                                                                          Core.caseAlternativeName = (Core.Name "int32"),+                                                                                          Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                                                                            Core.lambdaParameter = (Core.Name "i"),+                                                                                            Core.lambdaDomain = Nothing,+                                                                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermVariable (Core.Name "i"))))}))}]}))}]})),+                                                                              Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))}))}]})),+                                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                                Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "field_maxWarnings"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                                    Core.recordTypeName = (Core.Name "hydra.validation.ValidationProfile"),+                                                    Core.recordFields = [+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "errorRules"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_errorRules"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "warningRules"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_warningRules"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "maxErrors"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_maxErrors"))},+                                                      Core.Field {+                                                        Core.fieldName = (Core.Name "maxWarnings"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "field_maxWarnings"))}]}))))}))}))}))}))}))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.validation.ValidationProfile")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.validation.validationResult"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "e"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                  Core.functionTypeCodomain = (Core.TypeFunction (Core.FunctionType {+                    Core.functionTypeDomain = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                    Core.functionTypeCodomain = (Core.TypeEither (Core.EitherType {+                      Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                      Core.eitherTypeRight = (Core.TypeVariable (Core.Name "e"))}))}))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg2"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.validation.ValidationResult")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "e"))}))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "e"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "cx"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                  Core.lambdaParameter = (Core.Name "raw"),+                  Core.lambdaDomain = Nothing,+                  Core.lambdaBody = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                        Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = (Core.Name "err"),+                          Core.lambdaDomain = Nothing,+                          Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "stripped"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                            Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                            Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                              Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected a record of type hydra.validation.ValidationResult"))}))))),+                            Core.caseStatementCases = [+                              Core.CaseAlternative {+                                Core.caseAlternativeName = (Core.Name "record"),+                                Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                  Core.lambdaParameter = (Core.Name "record"),+                                  Core.lambdaDomain = Nothing,+                                  Core.lambdaBody = (Core.TermLet (Core.Let {+                                    Core.letBindings = [+                                      Core.Binding {+                                        Core.bindingName = (Core.Name "fieldMap"),+                                        Core.bindingTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.toFieldMap")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "record"))})),+                                        Core.bindingTypeScheme = Nothing}],+                                    Core.letBody = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "errors"))})),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "field_errors"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bind")),+                                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.requireField")),+                                                    Core.applicationArgument = (Core.TermLiteral (Core.LiteralString "warnings"))})),+                                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeList")),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "fieldMap"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))}))})),+                                          Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                            Core.lambdaParameter = (Core.Name "field_warnings"),+                                            Core.lambdaDomain = Nothing,+                                            Core.lambdaBody = (Core.TermEither (Right (Core.TermRecord (Core.Record {+                                              Core.recordTypeName = (Core.Name "hydra.validation.ValidationResult"),+                                              Core.recordFields = [+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "errors"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_errors"))},+                                                Core.Field {+                                                  Core.fieldName = (Core.Name "warnings"),+                                                  Core.fieldTerm = (Core.TermVariable (Core.Name "field_warnings"))}]}))))}))}))}))}))}))}))}]})),+                          Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.validation.ValidationResult")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Decode/Variants.hs view
@@ -0,0 +1,1845 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.decode.variants++module Hydra.Sources.Decode.Variants where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.decode.variants"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term decoders for hydra.variants"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.extract.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.lexical"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.rewriting"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.variants"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.decode.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.variants.literalVariant"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.variants.LiteralVariant"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "binary"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "boolean"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "decimal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "float"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "integer"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.LiteralVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "string"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.variants.LiteralVariant")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.variants.termVariant"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.variants.TermVariant"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "annotated"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "application"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "cases"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "either"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inject"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "inject"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambda"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "lambda"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "let"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "let"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "list"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "literal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "map"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "optional"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pair"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "project"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "record"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "set"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplication"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeApplication"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambda"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "typeLambda"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unit"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unwrap"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unwrap"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "variable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TermVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "wrap"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.variants.TermVariant")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.decode.variants.typeVariant"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.graph.Graph")),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeEither (Core.EitherType {+                Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.variants.TypeVariant"))}))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "cx"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "raw"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.either")),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "err"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermEither (Left (Core.TermVariable (Core.Name "err"))))}))})),+                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "stripped"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermCases (Core.CaseStatement {+                          Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+                          Core.caseStatementDefault = (Just (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected union"))}))))),+                          Core.caseStatementCases = [+                            Core.CaseAlternative {+                              Core.caseAlternativeName = (Core.Name "inject"),+                              Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = (Core.Name "inj"),+                                Core.lambdaDomain = Nothing,+                                Core.lambdaBody = (Core.TermLet (Core.Let {+                                  Core.letBindings = [+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "field"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                          Core.projectionFieldName = (Core.Name "field")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "inj"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fname"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "name")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "fterm"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermProject (Core.Projection {+                                          Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                          Core.projectionFieldName = (Core.Name "term")})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "field"))})),+                                      Core.bindingTypeScheme = Nothing},+                                    Core.Binding {+                                      Core.bindingName = (Core.Name "variantMap"),+                                      Core.bindingTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),+                                        Core.applicationArgument = (Core.TermList [+                                          Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "annotated"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "application"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "either"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forall"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "forall"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "function"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "list"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "literal"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "map"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "optional"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "pair"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "record"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "set"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "union"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "unit"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "variable"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "void"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "void"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))})))),+                                          (Core.TermPair (+                                            Core.TermWrap (Core.WrappedTerm {+                                              Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                              Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}),+                                            (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "input"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.map")),+                                                  Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                    Core.lambdaParameter = (Core.Name "t"),+                                                    Core.lambdaDomain = Nothing,+                                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                      Core.injectionTypeName = (Core.Name "hydra.variants.TypeVariant"),+                                                      Core.injectionField = Core.Field {+                                                        Core.fieldName = (Core.Name "wrap"),+                                                        Core.fieldTerm = (Core.TermVariable (Core.Name "t"))}}))}))})),+                                                Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                                      Core.lambdaParameter = (Core.Name "cx"),+                                                      Core.lambdaDomain = Nothing,+                                                      Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                                                        Core.lambdaParameter = (Core.Name "t"),+                                                        Core.lambdaDomain = Nothing,+                                                        Core.lambdaBody = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.decodeUnit")),+                                                            Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))}))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "input"))}))}))}))))])})),+                                      Core.bindingTypeScheme = Nothing}],+                                  Core.letBody = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                        Core.applicationArgument = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "variantMap"))}))})),+                                      Core.applicationArgument = (Core.TermEither (Left (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.errors.DecodingError"),+                                        Core.wrappedTermBody = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.cat")),+                                          Core.applicationArgument = (Core.TermList [+                                            Core.TermLiteral (Core.LiteralString "no such field "),+                                            (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "fname"))})),+                                            (Core.TermLiteral (Core.LiteralString " in union"))])}))}))))})),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "f"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "fterm"))}))}))}))}))}))}]})),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "stripped"))}))}))})),+                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.extract.core.stripWithDecodingError")),+                      Core.applicationArgument = (Core.TermVariable (Core.Name "cx"))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "raw"))}))}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Decoder for hydra.variants.TypeVariant")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Ast.hs view
@@ -0,0 +1,1510 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.ast++module Hydra.Sources.Encode.Ast where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.ast"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.ast"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.ast"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.associativity"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Associativity")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.ast.Associativity"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "none"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "left"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "right"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "both"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Associativity"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "both"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Associativity")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.blockStyle"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.BlockStyle")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.BlockStyle"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indent"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "x"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "literal"),+                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "string"),+                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+                                      Core.projectionFieldName = (Core.Name "indent")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "newlineBeforeContent"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "boolean"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+                                      Core.projectionFieldName = (Core.Name "newlineBeforeContent")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "newlineAfterContent"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "boolean"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.BlockStyle"),+                                      Core.projectionFieldName = (Core.Name "newlineAfterContent")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.BlockStyle")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.bracketExpr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.BracketExpr")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.BracketExpr"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "brackets"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.brackets")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+                                      Core.projectionFieldName = (Core.Name "brackets")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "enclosed"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+                                      Core.projectionFieldName = (Core.Name "enclosed")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "style"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.blockStyle")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.BracketExpr"),+                                      Core.projectionFieldName = (Core.Name "style")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.BracketExpr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.brackets"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Brackets")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Brackets"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "open"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"),+                                      Core.projectionFieldName = (Core.Name "open")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "close"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Brackets"),+                                      Core.projectionFieldName = (Core.Name "close")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Brackets")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.expr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Expr")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.ast.Expr"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "const"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "const"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "indent"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indent"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.indentedExpression")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "op"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.opExpr")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "brackets"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "brackets"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.bracketExpr")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "seq"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Expr"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "seq"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.seqExpr")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Expr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.indentStyle"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.IndentStyle")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.ast.IndentStyle"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "allLines"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.IndentStyle"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "allLines"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "string"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "subsequentLines"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.IndentStyle"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subsequentLines"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "string"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.IndentStyle")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.indentedExpression"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.IndentedExpression")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.IndentedExpression"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "style"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.indentStyle")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"),+                                      Core.projectionFieldName = (Core.Name "style")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expr"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.IndentedExpression"),+                                      Core.projectionFieldName = (Core.Name "expr")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.IndentedExpression")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.op"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Op")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Op"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "symbol"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.symbol")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+                                      Core.projectionFieldName = (Core.Name "symbol")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "padding"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.padding")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+                                      Core.projectionFieldName = (Core.Name "padding")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "precedence"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.precedence")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+                                      Core.projectionFieldName = (Core.Name "precedence")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "associativity"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.associativity")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Op"),+                                      Core.projectionFieldName = (Core.Name "associativity")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Op")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.opExpr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.OpExpr")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.OpExpr"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.op")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+                                      Core.projectionFieldName = (Core.Name "op")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lhs"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+                                      Core.projectionFieldName = (Core.Name "lhs")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "rhs"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.expr")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.OpExpr"),+                                      Core.projectionFieldName = (Core.Name "rhs")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.OpExpr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.padding"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Padding")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Padding"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.ws")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Padding"),+                                      Core.projectionFieldName = (Core.Name "left")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.ws")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.Padding"),+                                      Core.projectionFieldName = (Core.Name "right")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Padding")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.precedence"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Precedence")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Precedence"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "integer"),+                                    Core.fieldTerm = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "int32"),+                                        Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.ast.Precedence")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Precedence")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.seqExpr"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.SeqExpr")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.SeqExpr"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "op"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.ast.op")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"),+                                      Core.projectionFieldName = (Core.Name "op")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "elements"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.ast.expr"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.ast.SeqExpr"),+                                      Core.projectionFieldName = (Core.Name "elements")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.SeqExpr")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.symbol"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Symbol")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Symbol"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.ast.Symbol")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Symbol")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.ast.ws"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.ast.Ws")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.ast.Ws"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "none"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "none"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "space"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "space"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "break"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "break"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "breakAndIndent"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "breakAndIndent"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "string"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "doubleBreak"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.ast.Ws"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "doubleBreak"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.ast.Ws")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Coders.hs view
@@ -0,0 +1,641 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.coders++module Hydra.Sources.Encode.Coders where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.coders"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.coders"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.errors"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.graph"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.coders"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.caseConventions"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.CaseConventions")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.CaseConventions"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constant"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "constant")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "directory"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "directory")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "enumValue"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "enumValue")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "field"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "field")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "file"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "file")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "module"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "module")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "term")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariable"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "termVariable")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariable"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.coders.CaseConventions"),+                                      Core.projectionFieldName = (Core.Name "typeVariable")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.CaseConventions")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.coderDirection"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.CoderDirection")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.coders.CoderDirection"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "encode"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.CoderDirection"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "encode"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "decode"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.CoderDirection"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decode"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.CoderDirection")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.languageFeature"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.LanguageFeature")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.coders.LanguageFeature"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "partialApplication"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageFeature"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "partialApplication"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "nestedCaseStatements"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageFeature"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedCaseStatements"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "nestedPolymorphicLetBindings"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageFeature"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedPolymorphicLetBindings"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.LanguageFeature")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.languageName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.LanguageName")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.LanguageName"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.coders.LanguageName")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.LanguageName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.coders.traversalOrder"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.coders.TraversalOrder")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.coders.TraversalOrder"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pre"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.TraversalOrder"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pre"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "post"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.coders.TraversalOrder"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "post"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.coders.TraversalOrder")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Core.hs view
@@ -0,0 +1,4860 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.core++module Hydra.Sources.Encode.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.core"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.core"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.annotatedTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedTerm")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.AnnotatedTerm"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotation"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedTerm"),+                                      Core.projectionFieldName = (Core.Name "annotation")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.AnnotatedTerm")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.annotatedType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.AnnotatedType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.AnnotatedType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotation"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.AnnotatedType"),+                                      Core.projectionFieldName = (Core.Name "annotation")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.AnnotatedType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.application"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Application")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Application"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Application"),+                                      Core.projectionFieldName = (Core.Name "function")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "argument"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Application"),+                                      Core.projectionFieldName = (Core.Name "argument")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Application")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.applicationType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.ApplicationType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.ApplicationType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"),+                                      Core.projectionFieldName = (Core.Name "function")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "argument"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.ApplicationType"),+                                      Core.projectionFieldName = (Core.Name "argument")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.ApplicationType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.binding"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Binding")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Binding"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+                                      Core.projectionFieldName = (Core.Name "term")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeScheme"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeScheme"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Binding"),+                                      Core.projectionFieldName = (Core.Name "typeScheme")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Binding")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.caseAlternative"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.CaseAlternative")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.CaseAlternative"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "handler"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.CaseAlternative"),+                                      Core.projectionFieldName = (Core.Name "handler")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.CaseAlternative")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.caseStatement"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.CaseStatement")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.CaseStatement"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "default"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+                                      Core.projectionFieldName = (Core.Name "default")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.caseAlternative"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.CaseStatement"),+                                      Core.projectionFieldName = (Core.Name "cases")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.CaseStatement")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.eitherType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.EitherType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.EitherType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.EitherType"),+                                      Core.projectionFieldName = (Core.Name "left")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.EitherType"),+                                      Core.projectionFieldName = (Core.Name "right")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.EitherType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.field"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Field")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Field"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Field"),+                                      Core.projectionFieldName = (Core.Name "term")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Field")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.fieldType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FieldType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FieldType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.FieldType"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.FieldType"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FieldType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.floatType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FloatType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.FloatType"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "float32"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "float64"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FloatType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.floatValue"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FloatValue")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.FloatValue"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "float32"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float32"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "float"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "float32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "float64"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FloatValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float64"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "float"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.FloatValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "float64"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FloatValue")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.forallType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.ForallType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.ForallType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameter"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.ForallType"),+                                      Core.projectionFieldName = (Core.Name "parameter")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.ForallType"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.ForallType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.functionType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.FunctionType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.FunctionType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domain"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"),+                                      Core.projectionFieldName = (Core.Name "domain")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "codomain"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.FunctionType"),+                                      Core.projectionFieldName = (Core.Name "codomain")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.FunctionType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.injection"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Injection")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Injection"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "field"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.field")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Injection"),+                                      Core.projectionFieldName = (Core.Name "field")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Injection")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.integerType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.IntegerType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerType"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "bigint"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int8"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int16"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int32"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int64"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint8"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint16"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint32"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint64"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.IntegerType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.integerValue"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.IntegerValue")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.IntegerValue"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "bigint"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bigint"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "bigint"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int8"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int8"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int8"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int16"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int16"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int16"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int32"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int32"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "int64"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "int64"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int64"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint8"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint8"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "uint8"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint16"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint16"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "uint16"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint32"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint32"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "uint32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "uint64"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.IntegerValue"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "uint64"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "uint64"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.IntegerValue")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.lambda"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Lambda")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Lambda"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameter"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+                                      Core.projectionFieldName = (Core.Name "parameter")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domain"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+                                      Core.projectionFieldName = (Core.Name "domain")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Lambda"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Lambda")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.let"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Let")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Let"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bindings"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.binding"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Let"),+                                      Core.projectionFieldName = (Core.Name "bindings")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Let"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Let")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.literal"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Literal")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.Literal"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "binary"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "binary"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "boolean"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "boolean"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "decimal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "decimal"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "float"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.floatValue")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "integer"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.integerValue")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "string"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Literal"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "string"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Literal")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.literalType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.LiteralType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.LiteralType"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "binary"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "boolean"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "decimal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "float"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.floatType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "integer"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.integerType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "string"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.LiteralType"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.LiteralType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.mapType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.MapType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.MapType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "keys"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.MapType"),+                                      Core.projectionFieldName = (Core.Name "keys")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "values"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.MapType"),+                                      Core.projectionFieldName = (Core.Name "values")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.MapType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.name"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Name")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Name"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.core.Name")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Name")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.pairType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.PairType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.PairType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "first"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.PairType"),+                                      Core.projectionFieldName = (Core.Name "first")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "second"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.PairType"),+                                      Core.projectionFieldName = (Core.Name "second")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.PairType")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.projection"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Projection")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Projection"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Projection"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Projection"),+                                      Core.projectionFieldName = (Core.Name "fieldName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Projection")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.record"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Record")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Record"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Record"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fields"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.field"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.Record"),+                                      Core.projectionFieldName = (Core.Name "fields")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Record")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.term"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Term")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.Term"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "annotated"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.annotatedTerm")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "application"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.application")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "cases"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.caseStatement")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "either"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "e"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "either"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.eithers.bimap")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "e"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "inject"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inject"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.injection")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "lambda"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambda"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.lambda")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "let"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "let"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.let")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "list"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "xs"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "list"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "literal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literal")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "map"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "m"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "map"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "optional"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "opt"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "optional"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pair"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "p"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "pair"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "project"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.projection")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "record"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.record")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "set"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "s"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "set"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeApplication"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplication"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.typeApplicationTerm")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeLambda"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambda"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.typeLambda")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unit"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unwrap"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unwrap"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "variable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "wrap"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Term"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.wrappedTerm")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Term")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.type"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Type")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.Type"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "annotated"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.annotatedType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "application"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.applicationType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "either"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.eitherType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "forall"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forall"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.forallType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "function"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.functionType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "list"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "literal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literalType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "map"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.mapType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "optional"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pair"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.pairType")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "record"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "xs"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "list"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.fieldType"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "set"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "union"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "xs"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "list"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.fieldType"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unit"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "variable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "void"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "void"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "wrap"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.Type"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.Type")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeApplicationTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeApplicationTerm")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeApplicationTerm"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeApplicationTerm"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeApplicationTerm")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeClassConstraint"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeClassConstraint")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.core.TypeClassConstraint"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "simple"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeClassConstraint"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "simple"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeClassConstraint")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeLambda"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeLambda")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeLambda"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameter"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"),+                                      Core.projectionFieldName = (Core.Name "parameter")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeLambda"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeLambda")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeScheme"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeScheme"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variables"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+                                      Core.projectionFieldName = (Core.Name "variables")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constraints"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "m"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "map"),+                                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeVariableConstraints"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeScheme"),+                                      Core.projectionFieldName = (Core.Name "constraints")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeScheme")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.typeVariableConstraints"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.TypeVariableConstraints")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.TypeVariableConstraints"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "classes"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeClassConstraint"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.TypeVariableConstraints"),+                                      Core.projectionFieldName = (Core.Name "classes")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.TypeVariableConstraints")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.core.wrappedTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.WrappedTerm")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.core.WrappedTerm"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.core.WrappedTerm"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.core.WrappedTerm")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs view
@@ -0,0 +1,1426 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.error.checking++module Hydra.Sources.Encode.Error.Checking where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.error.checking"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.error.checking"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.checking"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.checkingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.CheckingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.error.checking.CheckingError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "incorrectUnification"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "incorrectUnification"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.incorrectUnificationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "notAForallType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAForallType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.notAForallTypeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "notAFunctionType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notAFunctionType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.notAFunctionTypeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "other"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.otherCheckingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeArityMismatch"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArityMismatch"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.typeArityMismatchError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeMismatch"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeMismatch"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.typeMismatchError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unboundTypeVariables"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unboundTypeVariables"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.unboundTypeVariablesError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedTermVariable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.undefinedTermVariableCheckingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unequalTypes"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unequalTypes"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.unequalTypesError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unsupportedTermVariant"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unsupportedTermVariant"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.unsupportedTermVariantError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "untypedLambda"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLambda"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.untypedLambdaError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "untypedLetBinding"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedLetBinding"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.untypedLetBindingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "untypedTermVariable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.CheckingError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.untypedTermVariableCheckingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.CheckingError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.incorrectUnificationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.IncorrectUnificationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.IncorrectUnificationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "substitution"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.typeSubst")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.IncorrectUnificationError"),+                                      Core.projectionFieldName = (Core.Name "substitution")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.IncorrectUnificationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.notAForallTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAForallTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.NotAForallTypeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArguments"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAForallTypeError"),+                                      Core.projectionFieldName = (Core.Name "typeArguments")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.NotAForallTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.notAFunctionTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.NotAFunctionTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.NotAFunctionTypeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.NotAFunctionTypeError"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.NotAFunctionTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.otherCheckingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.OtherCheckingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.OtherCheckingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.OtherCheckingError"),+                                      Core.projectionFieldName = (Core.Name "message")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.OtherCheckingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.typeArityMismatchError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeArityMismatchError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.TypeArityMismatchError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedArity"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+                                      Core.projectionFieldName = (Core.Name "expectedArity")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualArity"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+                                      Core.projectionFieldName = (Core.Name "actualArity")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeArguments"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeArityMismatchError"),+                                      Core.projectionFieldName = (Core.Name "typeArguments")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.TypeArityMismatchError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.typeMismatchError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.TypeMismatchError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.TypeMismatchError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+                                      Core.projectionFieldName = (Core.Name "expectedType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.TypeMismatchError"),+                                      Core.projectionFieldName = (Core.Name "actualType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.TypeMismatchError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.unboundTypeVariablesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UnboundTypeVariablesError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UnboundTypeVariablesError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variables"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "s"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "set"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+                                      Core.projectionFieldName = (Core.Name "variables")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UnboundTypeVariablesError"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UnboundTypeVariablesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.undefinedTermVariableCheckingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UndefinedTermVariableCheckingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UndefinedTermVariableCheckingError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UndefinedTermVariableCheckingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.unequalTypesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UnequalTypesError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UnequalTypesError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "types"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+                                      Core.projectionFieldName = (Core.Name "types")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UnequalTypesError"),+                                      Core.projectionFieldName = (Core.Name "description")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UnequalTypesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.unsupportedTermVariantError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UnsupportedTermVariantError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UnsupportedTermVariantError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariant"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.variants.termVariant")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UnsupportedTermVariantError"),+                                      Core.projectionFieldName = (Core.Name "termVariant")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UnsupportedTermVariantError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.untypedLambdaError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLambdaError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UntypedLambdaError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UntypedLambdaError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.untypedLetBindingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedLetBindingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UntypedLetBindingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binding"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.binding")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedLetBindingError"),+                                      Core.projectionFieldName = (Core.Name "binding")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UntypedLetBindingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.checking.untypedTermVariableCheckingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.checking.UntypedTermVariableCheckingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.checking.UntypedTermVariableCheckingError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.checking.UntypedTermVariableCheckingError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Error/Core.hs view
@@ -0,0 +1,3967 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.error.core++module Hydra.Sources.Encode.Error.Core where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.error.core"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.error.core"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.core"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.constantConditionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.ConstantConditionError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.ConstantConditionError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "value"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "boolean"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.ConstantConditionError"),+                                      Core.projectionFieldName = (Core.Name "value")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.ConstantConditionError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateBindingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateBindingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateBindingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateBindingError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateBindingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateFieldError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateFieldError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateFieldError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateFieldError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateFieldError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateRecordTypeFieldNamesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateRecordTypeFieldNamesError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateRecordTypeFieldNamesError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateRecordTypeFieldNamesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.duplicateUnionTypeFieldNamesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.DuplicateUnionTypeFieldNamesError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.DuplicateUnionTypeFieldNamesError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.DuplicateUnionTypeFieldNamesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyCaseStatementError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyCaseStatementError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyCaseStatementError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyCaseStatementError"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyCaseStatementError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyLetBindingsError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyLetBindingsError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyLetBindingsError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyLetBindingsError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyLetBindingsError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyRecordTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyRecordTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyRecordTypeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyRecordTypeError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyRecordTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyTermAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTermAnnotationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyTermAnnotationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTermAnnotationError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyTermAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyTypeAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeAnnotationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyTypeAnnotationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeAnnotationError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyTypeAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyTypeNameInTermError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyTypeNameInTermError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyTypeNameInTermError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyTypeNameInTermError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyTypeNameInTermError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.emptyUnionTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.EmptyUnionTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.EmptyUnionTypeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.EmptyUnionTypeError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.EmptyUnionTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidForallParameterNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidForallParameterNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidForallParameterNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidForallParameterNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidForallParameterNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidLambdaParameterNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLambdaParameterNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidLambdaParameterNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLambdaParameterNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidLambdaParameterNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidLetBindingNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLetBindingNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidLetBindingNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidLetBindingNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidLetBindingNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidLiteralError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidLiteralError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.error.core.InvalidLiteralError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeMismatch"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidLiteralError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeMismatch"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.literalTypeMismatchError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidLiteralError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTermError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTermError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.error.core.InvalidTermError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "constantCondition"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constantCondition"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.constantConditionError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateBinding"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateBindingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateFieldError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyCaseStatement"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyCaseStatement"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyCaseStatementError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyLetBindings"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyLetBindings"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyLetBindingsError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyTermAnnotation"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTermAnnotation"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyTermAnnotationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyTypeNameInTerm"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeNameInTerm"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyTypeNameInTermError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidLambdaParameterName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLambdaParameterName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidLambdaParameterNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidLetBindingName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLetBindingName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidLetBindingNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidTypeLambdaParameterName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeLambdaParameterName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidTypeLambdaParameterNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "nestedTermAnnotation"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTermAnnotation"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nestedTermAnnotationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "redundantWrapUnwrap"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "redundantWrapUnwrap"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.redundantWrapUnwrapError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "selfApplication"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "selfApplication"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.selfApplicationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "termVariableShadowing"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "termVariableShadowing"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.termVariableShadowingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeVariableShadowingInTypeLambda"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInTypeLambda"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.typeVariableShadowingInTypeLambdaError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedTermVariable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTermVariableError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedTypeVariableInBindingType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInBindingType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableInBindingTypeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedTypeVariableInLambdaDomain"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInLambdaDomain"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableInLambdaDomainError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedTypeVariableInTypeApplication"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariableInTypeApplication"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableInTypeApplicationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unknownPrimitiveName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unknownPrimitiveName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unknownPrimitiveNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unnecessaryIdentityApplication"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unnecessaryIdentityApplication"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unnecessaryIdentityApplicationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "untypedTermVariable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTermError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.untypedTermVariableError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTermError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.error.core.InvalidTypeError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateRecordTypeFieldNames"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateRecordTypeFieldNames"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateRecordTypeFieldNamesError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateUnionTypeFieldNames"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateUnionTypeFieldNames"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateUnionTypeFieldNamesError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyRecordType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyRecordType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyRecordTypeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyTypeAnnotation"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyTypeAnnotation"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyTypeAnnotationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyUnionType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyUnionType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.emptyUnionTypeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidForallParameterName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidForallParameterName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidForallParameterNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidTypeSchemeVariableName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidTypeSchemeVariableName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidTypeSchemeVariableNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "nestedTypeAnnotation"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nestedTypeAnnotation"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nestedTypeAnnotationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "nonComparableMapKeyType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableMapKeyType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nonComparableMapKeyTypeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "nonComparableSetElementType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nonComparableSetElementType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.nonComparableSetElementTypeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "singleVariantUnion"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "singleVariantUnion"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.singleVariantUnionError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeVariableShadowingInForall"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeVariableShadowingInForall"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.typeVariableShadowingInForallError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedTypeVariable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTypeVariable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTypeVariableError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "voidInNonBottomPosition"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "voidInNonBottomPosition"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.voidInNonBottomPositionError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTypeLambdaParameterNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeLambdaParameterNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeLambdaParameterNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTypeLambdaParameterNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.invalidTypeSchemeVariableNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.InvalidTypeSchemeVariableNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.InvalidTypeSchemeVariableNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.InvalidTypeSchemeVariableNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.literalTypeMismatchError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.LiteralTypeMismatchError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.LiteralTypeMismatchError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literalType")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+                                      Core.projectionFieldName = (Core.Name "expectedType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.literalType")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.LiteralTypeMismatchError"),+                                      Core.projectionFieldName = (Core.Name "actualType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.LiteralTypeMismatchError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nestedTermAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTermAnnotationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NestedTermAnnotationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTermAnnotationError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NestedTermAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nestedTypeAnnotationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NestedTypeAnnotationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NestedTypeAnnotationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.NestedTypeAnnotationError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NestedTypeAnnotationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nonComparableMapKeyTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableMapKeyTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NonComparableMapKeyTypeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "keyType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableMapKeyTypeError"),+                                      Core.projectionFieldName = (Core.Name "keyType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NonComparableMapKeyTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.nonComparableSetElementTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.NonComparableSetElementTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.NonComparableSetElementTypeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "elementType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.NonComparableSetElementTypeError"),+                                      Core.projectionFieldName = (Core.Name "elementType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.NonComparableSetElementTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.redundantWrapUnwrapError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.RedundantWrapUnwrapError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.RedundantWrapUnwrapError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.RedundantWrapUnwrapError"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.RedundantWrapUnwrapError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.selfApplicationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.SelfApplicationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.SelfApplicationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.SelfApplicationError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.SelfApplicationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.singleVariantUnionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.SingleVariantUnionError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.SingleVariantUnionError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.SingleVariantUnionError"),+                                      Core.projectionFieldName = (Core.Name "fieldName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.SingleVariantUnionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.termVariableShadowingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.TermVariableShadowingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.TermVariableShadowingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.TermVariableShadowingError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.TermVariableShadowingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.typeVariableShadowingInForallError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInForallError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.TypeVariableShadowingInForallError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInForallError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.TypeVariableShadowingInForallError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.typeVariableShadowingInTypeLambdaError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.TypeVariableShadowingInTypeLambdaError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.TypeVariableShadowingInTypeLambdaError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.TypeVariableShadowingInTypeLambdaError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedFieldError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedFieldError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedFieldError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+                                      Core.projectionFieldName = (Core.Name "fieldName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedFieldError"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedFieldError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTermVariableError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTermVariableError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTermVariableError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTermVariableError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTermVariableError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableInBindingTypeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableInBindingTypeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInBindingTypeError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableInBindingTypeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableInLambdaDomainError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInLambdaDomainError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableInLambdaDomainError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.undefinedTypeVariableInTypeApplicationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UndefinedTypeVariableInTypeApplicationError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UndefinedTypeVariableInTypeApplicationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unexpectedTermVariantError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTermVariantError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnexpectedTermVariantError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedVariant"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.variants.termVariant")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+                                      Core.projectionFieldName = (Core.Name "expectedVariant")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualTerm"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTermVariantError"),+                                      Core.projectionFieldName = (Core.Name "actualTerm")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnexpectedTermVariantError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unexpectedTypeVariantError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnexpectedTypeVariantError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnexpectedTypeVariantError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedVariant"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.variants.typeVariant")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+                                      Core.projectionFieldName = (Core.Name "expectedVariant")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actualType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UnexpectedTypeVariantError"),+                                      Core.projectionFieldName = (Core.Name "actualType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnexpectedTypeVariantError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unknownPrimitiveNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnknownPrimitiveNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnknownPrimitiveNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UnknownPrimitiveNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnknownPrimitiveNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.unnecessaryIdentityApplicationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UnnecessaryIdentityApplicationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UnnecessaryIdentityApplicationError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UnnecessaryIdentityApplicationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.untypedTermVariableError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.UntypedTermVariableError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.UntypedTermVariableError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.UntypedTermVariableError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.UntypedTermVariableError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.core.voidInNonBottomPositionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.core.VoidInNonBottomPositionError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.core.VoidInNonBottomPositionError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "location"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.core.VoidInNonBottomPositionError"),+                                      Core.projectionFieldName = (Core.Name "location")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.core.VoidInNonBottomPositionError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs view
@@ -0,0 +1,1158 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.error.packaging++module Hydra.Sources.Encode.Error.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.error.packaging"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.error.packaging"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.packaging"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.util"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.error.packaging"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.conflictingModuleNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingModuleNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.ConflictingModuleNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "first"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+                                      Core.projectionFieldName = (Core.Name "first")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "second"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingModuleNameError"),+                                      Core.projectionFieldName = (Core.Name "second")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.ConflictingModuleNameError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.conflictingVariantNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.ConflictingVariantNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.ConflictingVariantNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+                                      Core.projectionFieldName = (Core.Name "typeName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variantName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+                                      Core.projectionFieldName = (Core.Name "variantName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.ConflictingVariantNameError"),+                                      Core.projectionFieldName = (Core.Name "conflictingName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.ConflictingVariantNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.definitionNotInModuleNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DefinitionNotInModuleNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionNotInModuleNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DefinitionNotInModuleNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.definitionsOutOfOrderError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DefinitionsOutOfOrderError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "precedingName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+                                      Core.projectionFieldName = (Core.Name "precedingName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "followingName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DefinitionsOutOfOrderError"),+                                      Core.projectionFieldName = (Core.Name "followingName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DefinitionsOutOfOrderError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.duplicateDefinitionNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DuplicateDefinitionNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateDefinitionNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DuplicateDefinitionNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.duplicateModuleNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.DuplicateModuleNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.DuplicateModuleNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.DuplicateModuleNameError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.DuplicateModuleNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidDefinitionNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidDefinitionNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidDefinitionNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expectedConvention"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.util.caseConvention")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidDefinitionNameError"),+                                      Core.projectionFieldName = (Core.Name "expectedConvention")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidDefinitionNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidModuleError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.error.packaging.InvalidModuleError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "conflictingVariantName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingVariantName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.conflictingVariantNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "definitionNotInModuleName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitionNotInModuleName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.definitionNotInModuleNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "definitionsOutOfOrder"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitionsOutOfOrder"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.definitionsOutOfOrderError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateDefinitionName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateDefinitionName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.duplicateDefinitionNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidDefinitionName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidDefinitionName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidDefinitionNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidModuleNameConvention"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidModuleNameConvention"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidModuleNameConventionError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "missingDocumentation"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "missingDocumentation"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.missingDocumentationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidModuleError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidModuleNameConventionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidModuleNameConventionError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidModuleNameConventionError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidModuleNameConventionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidPackageError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.error.packaging.InvalidPackageError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "conflictingModuleName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conflictingModuleName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.conflictingModuleNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateModuleName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateModuleName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.duplicateModuleNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidModule"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidModule"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidModuleError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidPackageName"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidPackageName"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.packaging.invalidPackageNameError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidPackageError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.invalidPackageNameError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.InvalidPackageNameError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.InvalidPackageNameError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "packageName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.InvalidPackageNameError"),+                                      Core.projectionFieldName = (Core.Name "packageName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.InvalidPackageNameError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.error.packaging.missingDocumentationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.error.packaging.MissingDocumentationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.error.packaging.MissingDocumentationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.error.packaging.MissingDocumentationError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.error.packaging.MissingDocumentationError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Errors.hs view
@@ -0,0 +1,1915 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.errors++module Hydra.Sources.Encode.Errors where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.errors"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.errors"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.error.checking"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.error.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.variants"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.errors"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.decodingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.DecodingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.DecodingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.DecodingError")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.DecodingError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.emptyListError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = Core.TypeUnit,+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "_"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "unit"),+                  Core.fieldTerm = Core.TermUnit}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.EmptyListError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.error"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.Error")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.errors.Error"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "checking"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "checking"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.checkingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "decoding"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decoding"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.decodingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateBinding"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateBinding"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateBindingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "duplicateField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "duplicateField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.duplicateFieldError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "extraction"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "extraction"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.extractionError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "inference"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inference"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.inferenceError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "invalidLiteral"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "invalidLiteral"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.invalidLiteralError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "other"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.otherError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "resolution"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "resolution"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.resolutionError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedFieldError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "undefinedTermVariable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "undefinedTermVariable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.undefinedTermVariableError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "untypedTermVariable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "untypedTermVariable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.untypedTermVariableError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unexpectedTermVariant"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTermVariant"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unexpectedTermVariantError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unexpectedTypeVariant"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedTypeVariant"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.core.unexpectedTypeVariantError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unification"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.Error"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unification"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unificationError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.Error")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.extractionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.ExtractionError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.errors.ExtractionError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "emptyList"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "emptyList"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.emptyListError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "multipleBindings"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "multipleBindings"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.multipleBindingsError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "multipleFields"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "multipleFields"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.multipleFieldsError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "noMatchingField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noMatchingField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noMatchingFieldError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "noSuchBinding"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchBinding"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noSuchBindingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "notEnoughCases"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notEnoughCases"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.notEnoughCasesError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unexpectedShape"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ExtractionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedShape"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unexpectedShapeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.ExtractionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.inferenceError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.InferenceError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.errors.InferenceError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "checking"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.InferenceError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "checking"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.error.checking.checkingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "other"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.InferenceError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.otherInferenceError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unification"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.InferenceError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unification"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unificationInferenceError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.InferenceError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.multipleBindingsError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.MultipleBindingsError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.MultipleBindingsError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.MultipleBindingsError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.MultipleBindingsError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.multipleFieldsError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.MultipleFieldsError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.MultipleFieldsError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.MultipleFieldsError"),+                                      Core.projectionFieldName = (Core.Name "fieldName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.MultipleFieldsError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.noMatchingFieldError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.NoMatchingFieldError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.NoMatchingFieldError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "fieldName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.NoMatchingFieldError"),+                                      Core.projectionFieldName = (Core.Name "fieldName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NoMatchingFieldError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.noSuchBindingError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchBindingError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.NoSuchBindingError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.NoSuchBindingError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NoSuchBindingError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.noSuchPrimitiveError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.NoSuchPrimitiveError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.NoSuchPrimitiveError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.NoSuchPrimitiveError"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NoSuchPrimitiveError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.notEnoughCasesError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = Core.TypeUnit,+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "_"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "unit"),+                  Core.fieldTerm = Core.TermUnit}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.NotEnoughCasesError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.otherError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.OtherError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.OtherError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.OtherError")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.OtherError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.otherInferenceError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.OtherInferenceError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.OtherInferenceError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.OtherInferenceError"),+                                      Core.projectionFieldName = (Core.Name "message")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.OtherInferenceError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.otherResolutionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.OtherResolutionError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.OtherResolutionError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.errors.OtherResolutionError")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.OtherResolutionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.resolutionError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.ResolutionError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.errors.ResolutionError"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "noSuchBinding"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchBinding"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noSuchBindingError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "noSuchPrimitive"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noSuchPrimitive"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noSuchPrimitiveError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "noMatchingField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "noMatchingField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.noMatchingFieldError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "other"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "other"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.otherResolutionError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unexpectedShape"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.ResolutionError"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unexpectedShape"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unexpectedShapeError")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.ResolutionError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.unexpectedShapeError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.UnexpectedShapeError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.UnexpectedShapeError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "expected"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+                                      Core.projectionFieldName = (Core.Name "expected")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "actual"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.UnexpectedShapeError"),+                                      Core.projectionFieldName = (Core.Name "actual")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.UnexpectedShapeError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.unificationError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.UnificationError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.UnificationError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "leftType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+                                      Core.projectionFieldName = (Core.Name "leftType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "rightType"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+                                      Core.projectionFieldName = (Core.Name "rightType")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.UnificationError"),+                                      Core.projectionFieldName = (Core.Name "message")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.UnificationError")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.errors.unificationInferenceError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.errors.UnificationInferenceError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.errors.UnificationInferenceError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cause"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.errors.unificationError")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.errors.UnificationInferenceError"),+                                      Core.projectionFieldName = (Core.Name "cause")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.errors.UnificationInferenceError")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Json/Model.hs view
@@ -0,0 +1,326 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.json.model++module Hydra.Sources.Encode.Json.Model where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.json.model"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.json.model"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.json.model"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.json.model.value"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.json.model.Value")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.json.model.Value"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "array"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "array"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "xs"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "list"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.json.model.value"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "boolean"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "boolean"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "null"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "null"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "number"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "number"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "decimal"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "object"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "object"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "xs"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "list"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                  Core.lambdaParameter = (Core.Name "p"),+                                                  Core.lambdaDomain = Nothing,+                                                  Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "pair"),+                                                      Core.fieldTerm = (Core.TermApplication (Core.Application {+                                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")),+                                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                                              Core.lambdaParameter = (Core.Name "x"),+                                                              Core.lambdaDomain = Nothing,+                                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                                Core.injectionField = Core.Field {+                                                                  Core.fieldName = (Core.Name "literal"),+                                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                                    Core.injectionField = Core.Field {+                                                                      Core.fieldName = (Core.Name "string"),+                                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})),+                                                          Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.json.model.value"))})),+                                                        Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))}))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "string"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.json.model.Value"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "string"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.json.model.Value")))]))}))})]}
+ src/main/haskell/Hydra/Sources/Encode/Packaging.hs view
@@ -0,0 +1,1701 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.packaging++module Hydra.Sources.Encode.Packaging where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.packaging"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.packaging"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.typing"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.packaging"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.definition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Definition")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.packaging.Definition"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "term"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Definition"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.termDefinition")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "type"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Definition"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.typeDefinition")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "primitive"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Definition"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primitive"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.primitiveDefinition")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Definition")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.definitionReference"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.DefinitionReference")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.packaging.DefinitionReference"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "type"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.DefinitionReference"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "term"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.DefinitionReference"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "primitive"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.DefinitionReference"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primitive"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.DefinitionReference")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.entityMetadata"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.EntityMetadata")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityMetadata"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "x"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "literal"),+                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "string"),+                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+                                      Core.projectionFieldName = (Core.Name "description")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "comments"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "x"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "literal"),+                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "string"),+                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+                                      Core.projectionFieldName = (Core.Name "comments")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "seeAlso"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityReference"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+                                      Core.projectionFieldName = (Core.Name "seeAlso")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lifecycle"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.lifecycleInfo"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.EntityMetadata"),+                                      Core.projectionFieldName = (Core.Name "lifecycle")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.EntityMetadata")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.entityReference"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.EntityReference")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.packaging.EntityReference"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "package"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityReference"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "package"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "module"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityReference"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "module"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "definition"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.EntityReference"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definition"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.definitionReference")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.EntityReference")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.lifecycleInfo"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.LifecycleInfo")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.LifecycleInfo"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "availableSince"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.version"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+                                      Core.projectionFieldName = (Core.Name "availableSince")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "deprecatedSince"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.version"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.LifecycleInfo"),+                                      Core.projectionFieldName = (Core.Name "deprecatedSince")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.LifecycleInfo")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.module"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Module")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Module"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+                                      Core.projectionFieldName = (Core.Name "metadata")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "dependencies"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleDependency"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+                                      Core.projectionFieldName = (Core.Name "dependencies")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "definitions"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.definition"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Module"),+                                      Core.projectionFieldName = (Core.Name "definitions")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Module")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.moduleDependency"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleDependency")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.ModuleDependency"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "module"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+                                      Core.projectionFieldName = (Core.Name "module")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "package"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.ModuleDependency"),+                                      Core.projectionFieldName = (Core.Name "package")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.ModuleDependency")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.moduleName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.ModuleName")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.ModuleName"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.ModuleName")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.ModuleName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.package"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Package")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Package"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+                                      Core.projectionFieldName = (Core.Name "metadata")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "dependencies"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageDependency"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+                                      Core.projectionFieldName = (Core.Name "dependencies")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "modules"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.module"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.Package"),+                                      Core.projectionFieldName = (Core.Name "modules")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Package")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.packageDependency"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.PackageDependency")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.PackageDependency"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.packageName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "version"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.packaging.versionSpecifier")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PackageDependency"),+                                      Core.projectionFieldName = (Core.Name "version")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.PackageDependency")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.packageName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.PackageName")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.PackageName"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.PackageName")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.PackageName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.primitiveDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.PrimitiveDefinition")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.PrimitiveDefinition"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+                                      Core.projectionFieldName = (Core.Name "metadata")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "signature"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.termSignature")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+                                      Core.projectionFieldName = (Core.Name "signature")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "isPure"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "boolean"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+                                      Core.projectionFieldName = (Core.Name "isPure")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "isTotal"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "boolean"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+                                      Core.projectionFieldName = (Core.Name "isTotal")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "defaultImplementation"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.PrimitiveDefinition"),+                                      Core.projectionFieldName = (Core.Name "defaultImplementation")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.PrimitiveDefinition")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.termDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.TermDefinition")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.TermDefinition"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+                                      Core.projectionFieldName = (Core.Name "metadata")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "signature"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.typing.termSignature"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+                                      Core.projectionFieldName = (Core.Name "signature")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.TermDefinition"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.TermDefinition")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.typeDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.TypeDefinition")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.TypeDefinition"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "metadata"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.entityMetadata"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+                                      Core.projectionFieldName = (Core.Name "metadata")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.typeScheme")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.packaging.TypeDefinition"),+                                      Core.projectionFieldName = (Core.Name "body")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.TypeDefinition")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.version"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.Version")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.Version"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.packaging.Version")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.Version")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.packaging.versionSpecifier"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.packaging.VersionSpecifier")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.packaging.VersionSpecifier"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "any"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.packaging.VersionSpecifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "any"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.packaging.VersionSpecifier")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Parsing.hs view
@@ -0,0 +1,317 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.parsing++module Hydra.Sources.Encode.Parsing where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.parsing"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.parsing"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.parsing"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.parsing.parseError"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.parsing.ParseError")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseError"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "message"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"),+                                      Core.projectionFieldName = (Core.Name "message")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "remainder"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.parsing.ParseError"),+                                      Core.projectionFieldName = (Core.Name "remainder")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.parsing.ParseError")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.parsing.parseResult"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.parsing.ParseResult")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermCases (Core.CaseStatement {+                Core.caseStatementTypeName = (Core.Name "hydra.parsing.ParseResult"),+                Core.caseStatementDefault = Nothing,+                Core.caseStatementCases = [+                  Core.CaseAlternative {+                    Core.caseAlternativeName = (Core.Name "success"),+                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "y"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                        Core.injectionField = Core.Field {+                          Core.fieldName = (Core.Name "inject"),+                          Core.fieldTerm = (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "typeName"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseResult"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "field"),+                                Core.fieldTerm = (Core.TermRecord (Core.Record {+                                  Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                  Core.recordFields = [+                                    Core.Field {+                                      Core.fieldName = (Core.Name "name"),+                                      Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "success"))}))},+                                    Core.Field {+                                      Core.fieldName = (Core.Name "term"),+                                      Core.fieldTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseSuccess")),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                  Core.CaseAlternative {+                    Core.caseAlternativeName = (Core.Name "failure"),+                    Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                      Core.lambdaParameter = (Core.Name "y"),+                      Core.lambdaDomain = Nothing,+                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                        Core.injectionField = Core.Field {+                          Core.fieldName = (Core.Name "inject"),+                          Core.fieldTerm = (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "typeName"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseResult"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "field"),+                                Core.fieldTerm = (Core.TermRecord (Core.Record {+                                  Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                  Core.recordFields = [+                                    Core.Field {+                                      Core.fieldName = (Core.Name "name"),+                                      Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                        Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                        Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "failure"))}))},+                                    Core.Field {+                                      Core.fieldName = (Core.Name "term"),+                                      Core.fieldTerm = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.parsing.parseError")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.parsing.ParseResult")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.parsing.parseSuccess"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.parsing.ParseSuccess")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.parsing.ParseSuccess"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "value"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "a")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+                                        Core.projectionFieldName = (Core.Name "value")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "remainder"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "x"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "literal"),+                                          Core.fieldTerm = (Core.TermInject (Core.Injection {+                                            Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                            Core.injectionField = Core.Field {+                                              Core.fieldName = (Core.Name "string"),+                                              Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.parsing.ParseSuccess"),+                                        Core.projectionFieldName = (Core.Name "remainder")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.parsing.ParseSuccess")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Paths.hs view
@@ -0,0 +1,2226 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.paths++module Hydra.Sources.Encode.Paths where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.paths"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.paths"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.paths"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermEdge"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermEdge")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermEdge"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "source"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermNode")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+                                      Core.projectionFieldName = (Core.Name "source")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermPath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "target"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermNode")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermEdge"),+                                      Core.projectionFieldName = (Core.Name "target")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermEdge")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermGraph"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermGraph")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermGraph"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nodes"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermNode"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"),+                                      Core.projectionFieldName = (Core.Name "nodes")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "edges"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermEdge"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermGraph"),+                                      Core.projectionFieldName = (Core.Name "edges")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermGraph")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermNode"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermNode")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermNode"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "label"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+                                      Core.projectionFieldName = (Core.Name "label")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "id"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtermNode"),+                                      Core.projectionFieldName = (Core.Name "id")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermNode")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermPath"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermPath")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermPath"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "xs"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "list"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermStep"))})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtermPath")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermPath")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtermStep"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtermStep")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.paths.SubtermStep"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "annotatedBody"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotatedBody"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "applicationFunction"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationFunction"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "applicationArgument"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationArgument"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "lambdaBody"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambdaBody"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unionCasesDefault"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionCasesDefault"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unionCasesBranch"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionCasesBranch"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "letBody"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "letBody"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "letBinding"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "letBinding"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "listElement"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "listElement"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "mapKey"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapKey"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "mapValue"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapValue"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "optionalTerm"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optionalTerm"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "productTerm"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "productTerm"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "recordField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "recordField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "setElement"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "setElement"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "sumTerm"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "sumTerm"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeLambdaBody"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambdaBody"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeApplicationTerm"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplicationTerm"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "injectionTerm"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "injectionTerm"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "wrappedTerm"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtermStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrappedTerm"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtermStep")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeEdge"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeEdge")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeEdge"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "source"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeNode")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+                                      Core.projectionFieldName = (Core.Name "source")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypePath")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "target"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeNode")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeEdge"),+                                      Core.projectionFieldName = (Core.Name "target")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeEdge")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeGraph"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeGraph")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeGraph"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "nodes"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeNode"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+                                      Core.projectionFieldName = (Core.Name "nodes")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "edges"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeEdge"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeGraph"),+                                      Core.projectionFieldName = (Core.Name "edges")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeGraph")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeNode"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeNode")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeNode"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "label"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+                                      Core.projectionFieldName = (Core.Name "label")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "id"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.paths.SubtypeNode"),+                                      Core.projectionFieldName = (Core.Name "id")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeNode")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypePath"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypePath")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypePath"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "xs"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "list"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtypeStep"))})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.paths.SubtypePath")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypePath")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.paths.subtypeStep"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.paths.SubtypeStep")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.paths.SubtypeStep"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "annotatedBody"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotatedBody"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "applicationFunction"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationFunction"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "applicationArgument"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "applicationArgument"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "eitherLeft"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "eitherLeft"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "eitherRight"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "eitherRight"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "forallBody"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forallBody"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "functionDomain"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "functionDomain"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "functionCodomain"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "functionCodomain"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "listElement"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "listElement"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "mapKeys"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapKeys"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "mapValues"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapValues"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "optionalElement"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optionalElement"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pairFirst"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pairFirst"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pairSecond"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pairSecond"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "recordField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "recordField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "setElement"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "setElement"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unionField"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unionField"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "wrappedType"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.paths.SubtypeStep"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrappedType"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.paths.SubtypeStep")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Query.hs view
@@ -0,0 +1,1873 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.query++module Hydra.Sources.Encode.Query where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.query"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.query"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.query"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.comparisonConstraint"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.ComparisonConstraint")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.query.ComparisonConstraint"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "equal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "equal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "notEqual"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "notEqual"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "lessThan"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThan"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "greaterThan"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThan"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "lessThanOrEqual"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThanOrEqual"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "greaterThanOrEqual"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.ComparisonConstraint"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThanOrEqual"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.ComparisonConstraint")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.edge"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Edge")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Edge"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "out"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+                                      Core.projectionFieldName = (Core.Name "out")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "in"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.Edge"),+                                      Core.projectionFieldName = (Core.Name "in")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Edge")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.graphPattern"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.GraphPattern")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.GraphPattern"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "graph"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"),+                                      Core.projectionFieldName = (Core.Name "graph")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "patterns"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.GraphPattern"),+                                      Core.projectionFieldName = (Core.Name "patterns")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.GraphPattern")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.node"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Node")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.query.Node"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "term"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Node"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "variable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Node"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.variable")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "wildcard"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Node"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wildcard"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Node")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.path"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Path")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.query.Path"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "step"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Path"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "step"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.step")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "regex"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Path"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "regex"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.regexSequence")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "inverse"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Path"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inverse"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Path")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.pathEquation"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.PathEquation")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.PathEquation"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"),+                                      Core.projectionFieldName = (Core.Name "left")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.PathEquation"),+                                      Core.projectionFieldName = (Core.Name "right")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.PathEquation")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.pattern"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Pattern")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.query.Pattern"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "triple"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "triple"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.triplePattern")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "negation"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "negation"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.pattern")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "conjunction"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "conjunction"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "xs"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "list"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "disjunction"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "disjunction"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "xs"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "list"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "graph"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Pattern"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "graph"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.graphPattern")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Pattern")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.patternImplication"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.PatternImplication")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.PatternImplication"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "antecedent"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.pattern")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"),+                                      Core.projectionFieldName = (Core.Name "antecedent")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "consequent"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.pattern")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.PatternImplication"),+                                      Core.projectionFieldName = (Core.Name "consequent")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.PatternImplication")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.query"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Query")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Query"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variables"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.variable"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.Query"),+                                      Core.projectionFieldName = (Core.Name "variables")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "patterns"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.query.pattern"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.Query"),+                                      Core.projectionFieldName = (Core.Name "patterns")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Query")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.range"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Range")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Range"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "min"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.Range"),+                                      Core.projectionFieldName = (Core.Name "min")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "max"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.Range"),+                                      Core.projectionFieldName = (Core.Name "max")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Range")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.regexQuantifier"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.RegexQuantifier")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.query.RegexQuantifier"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "one"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "one"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "zeroOrOne"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "zeroOrOne"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "zeroOrMore"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "zeroOrMore"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "oneOrMore"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "oneOrMore"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "exactly"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "exactly"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "atLeast"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "atLeast"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "range"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexQuantifier"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "range"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.range")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.RegexQuantifier")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.regexSequence"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.RegexSequence")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.RegexSequence"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "path"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"),+                                      Core.projectionFieldName = (Core.Name "path")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "quantifier"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.regexQuantifier")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.RegexSequence"),+                                      Core.projectionFieldName = (Core.Name "quantifier")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.RegexSequence")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.step"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Step")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.query.Step"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "edge"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Step"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "edge"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.edge")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "project"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Step"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.projection")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "compare"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Step"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "compare"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.comparisonConstraint")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Step")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.triplePattern"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.TriplePattern")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.TriplePattern"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subject"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.node")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+                                      Core.projectionFieldName = (Core.Name "subject")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "predicate"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.path")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+                                      Core.projectionFieldName = (Core.Name "predicate")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "object"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.query.node")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.query.TriplePattern"),+                                      Core.projectionFieldName = (Core.Name "object")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.TriplePattern")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.query.variable"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.query.Variable")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.query.Variable"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.query.Variable")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.query.Variable")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Relational.hs view
@@ -0,0 +1,721 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.relational++module Hydra.Sources.Encode.Relational where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.relational"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.relational"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.relational"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.columnName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.ColumnName")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.ColumnName"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.ColumnName")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.ColumnName")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.columnSchema"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "t"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.ColumnSchema")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "t"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.ColumnSchema"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"),+                                        Core.projectionFieldName = (Core.Name "name")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domain"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "t")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.relational.ColumnSchema"),+                                        Core.projectionFieldName = (Core.Name "domain")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.ColumnSchema")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.foreignKey"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.ForeignKey")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.ForeignKey"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "foreignRelation"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"),+                                      Core.projectionFieldName = (Core.Name "foreignRelation")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "keys"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "m"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "map"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.relational.ForeignKey"),+                                      Core.projectionFieldName = (Core.Name "keys")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.ForeignKey")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.primaryKey"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.PrimaryKey")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.PrimaryKey"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "xs"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "list"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.PrimaryKey")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.PrimaryKey")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relation"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Relation")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "wrap"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.Relation"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "body"),+                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                              Core.lambdaParameter = (Core.Name "xs"),+                              Core.lambdaDomain = Nothing,+                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                Core.injectionField = Core.Field {+                                  Core.fieldName = (Core.Name "list"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                      Core.applicationArgument = (Core.TermApplication (Core.Application {+                                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.row")),+                                        Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Relation")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.Relation")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relationName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.relational.RelationName")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.RelationName"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.RelationName")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.RelationName")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relationSchema"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "t"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "t")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.RelationSchema")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "t"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "t"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.RelationSchema"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationName")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+                                        Core.projectionFieldName = (Core.Name "name")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "columns"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.columnSchema")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "t"))}))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+                                        Core.projectionFieldName = (Core.Name "columns")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "primaryKeys"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.primaryKey"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+                                        Core.projectionFieldName = (Core.Name "primaryKeys")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "foreignKeys"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.foreignKey"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.relational.RelationSchema"),+                                        Core.projectionFieldName = (Core.Name "foreignKeys")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.RelationSchema")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.relationship"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = [+                  Core.TypeClassConstraintSimple (Core.Name "ordering")]}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Relationship")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "wrap"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.Relationship"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "body"),+                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                              Core.lambdaParameter = (Core.Name "s"),+                              Core.lambdaDomain = Nothing,+                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                Core.injectionField = Core.Field {+                                  Core.fieldName = (Core.Name "set"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "m"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "map"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                                  Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName"))})),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))}))})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Relationship")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.Relationship")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.relational.row"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.relational.Row")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "wrap"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.relational.Row"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "body"),+                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                              Core.lambdaParameter = (Core.Name "xs"),+                              Core.lambdaDomain = Nothing,+                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                Core.injectionField = Core.Field {+                                  Core.fieldName = (Core.Name "list"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.relational.Row")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.relational.Row")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Tabular.hs view
@@ -0,0 +1,424 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.tabular++module Hydra.Sources.Encode.Tabular where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.tabular"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.tabular"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.relational"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.tabular"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.columnType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.tabular.ColumnType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.ColumnType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.columnName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.tabular.ColumnType"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.ColumnType")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.dataRow"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.tabular.DataRow")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "wrap"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.DataRow"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "body"),+                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                              Core.lambdaParameter = (Core.Name "xs"),+                              Core.lambdaDomain = Nothing,+                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                Core.injectionField = Core.Field {+                                  Core.fieldName = (Core.Name "list"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "opt"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "optional"),+                                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "v"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))}))})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.tabular.DataRow")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.DataRow")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.headerRow"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.tabular.HeaderRow")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.HeaderRow"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "xs"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "list"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                    Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "x"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "literal"),+                                          Core.fieldTerm = (Core.TermInject (Core.Injection {+                                            Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                            Core.injectionField = Core.Field {+                                              Core.fieldName = (Core.Name "string"),+                                              Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.tabular.HeaderRow")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.HeaderRow")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.table"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "v"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "v")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.tabular.Table")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "v"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "v"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.Table"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "header"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "opt"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "optional"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.tabular.headerRow"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.tabular.Table"),+                                        Core.projectionFieldName = (Core.Name "header")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "data"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.tabular.dataRow")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "v"))}))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.tabular.Table"),+                                        Core.projectionFieldName = (Core.Name "data")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.Table")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.tabular.tableType"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.tabular.TableType")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.tabular.TableType"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.relational.relationName")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "columns"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.tabular.columnType"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.tabular.TableType"),+                                      Core.projectionFieldName = (Core.Name "columns")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.tabular.TableType")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Testing.hs view
@@ -0,0 +1,77 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.testing++module Hydra.Sources.Encode.Testing where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.testing"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.testing"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.testing"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.testing.tag"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.testing.Tag")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.testing.Tag"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.testing.Tag")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.testing.Tag")))]))}))})]}
+ src/main/haskell/Hydra/Sources/Encode/Topology.hs view
@@ -0,0 +1,358 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.topology++module Hydra.Sources.Encode.Topology where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.topology"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.topology"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.topology"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.topology.graph"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeMap (Core.MapType {+                  Core.mapTypeKeys = (Core.TypeVariable (Core.Name "hydra.topology.Vertex")),+                  Core.mapTypeValues = (Core.TypeList (Core.TypeVariable (Core.Name "hydra.topology.Vertex")))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "m"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "map"),+                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                      Core.applicationFunction = (Core.TermApplication (Core.Application {+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                        Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})),+                      Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = (Core.Name "xs"),+                        Core.lambdaDomain = Nothing,+                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                          Core.injectionField = Core.Field {+                            Core.fieldName = (Core.Name "list"),+                            Core.fieldTerm = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))}))})),+                    Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.topology.Graph")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.topology.tarjanState"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.topology.TarjanState")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.topology.TarjanState"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "counter"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+                                      Core.projectionFieldName = (Core.Name "counter")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "indices"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "m"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "map"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "x"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "literal"),+                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "integer"),+                                                      Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                        Core.injectionField = Core.Field {+                                                          Core.fieldName = (Core.Name "int32"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+                                      Core.projectionFieldName = (Core.Name "indices")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lowLinks"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "m"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "map"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "x"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "literal"),+                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "integer"),+                                                      Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                        Core.injectionField = Core.Field {+                                                          Core.fieldName = (Core.Name "int32"),+                                                          Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+                                      Core.projectionFieldName = (Core.Name "lowLinks")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "stack"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+                                      Core.projectionFieldName = (Core.Name "stack")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "onStack"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "s"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "set"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+                                      Core.projectionFieldName = (Core.Name "onStack")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "sccs"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "xs"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "list"),+                                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.topology.vertex"))})),+                                                    Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.topology.TarjanState"),+                                      Core.projectionFieldName = (Core.Name "sccs")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.topology.TarjanState")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.topology.vertex"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.core.Literal")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "literal"),+                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                    Core.injectionField = Core.Field {+                      Core.fieldName = (Core.Name "integer"),+                      Core.fieldTerm = (Core.TermInject (Core.Injection {+                        Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                        Core.injectionField = Core.Field {+                          Core.fieldName = (Core.Name "int32"),+                          Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.topology.Vertex")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Typed.hs view
@@ -0,0 +1,255 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.typed++module Hydra.Sources.Encode.Typed where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.typed"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.typed"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typed"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typed.typedBinding"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedBinding")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typed.TypedBinding"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typed.TypedBinding"),+                                        Core.projectionFieldName = (Core.Name "name")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typed.typedTerm")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typed.TypedBinding"),+                                        Core.projectionFieldName = (Core.Name "term")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typed.TypedBinding")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typed.typedTerm"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTerm")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "wrap"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typed.TypedTerm"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "body"),+                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                            Core.applicationArgument = (Core.TermApplication (Core.Application {+                              Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typed.TypedTerm")),+                              Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typed.TypedTerm")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typed.typedTermDefinition"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "a"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "a")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typed.TypedTermDefinition")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "a"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "a"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typed.TypedTermDefinition"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typed.TypedTermDefinition"),+                                        Core.projectionFieldName = (Core.Name "name")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typed.typedTerm")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "a"))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typed.TypedTermDefinition"),+                                        Core.projectionFieldName = (Core.Name "term")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typed.TypedTermDefinition")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Typing.hs view
@@ -0,0 +1,1173 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.typing++module Hydra.Sources.Encode.Typing where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.typing"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.typing"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.paths"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.typing"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.functionStructure"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "env"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "env")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.typing.FunctionStructure")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "env"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "env"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.FunctionStructure"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeParams"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                        Core.projectionFieldName = (Core.Name "typeParams")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "params"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                        Core.projectionFieldName = (Core.Name "params")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bindings"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.binding"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                        Core.projectionFieldName = (Core.Name "bindings")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "body"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                        Core.projectionFieldName = (Core.Name "body")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "domains"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                        Core.projectionFieldName = (Core.Name "domains")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "codomain"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "opt"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "optional"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                        Core.projectionFieldName = (Core.Name "codomain")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "environment"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermVariable (Core.Name "env")),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.typing.FunctionStructure"),+                                        Core.projectionFieldName = (Core.Name "environment")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.FunctionStructure")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.inferenceContext"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.InferenceContext")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.InferenceContext"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "freshTypeVariableCount"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"),+                                      Core.projectionFieldName = (Core.Name "freshTypeVariableCount")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "trace"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.paths.subtermStep"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.InferenceContext"),+                                      Core.projectionFieldName = (Core.Name "trace")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.InferenceContext")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.inferenceResult"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.InferenceResult")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.InferenceResult"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "term"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.term")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+                                      Core.projectionFieldName = (Core.Name "term")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "subst"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.typeSubst")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+                                      Core.projectionFieldName = (Core.Name "subst")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "classConstraints"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "m"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "map"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeVariableConstraints"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+                                      Core.projectionFieldName = (Core.Name "classConstraints")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "context"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.inferenceContext")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.InferenceResult"),+                                      Core.projectionFieldName = (Core.Name "context")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.InferenceResult")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.parameter"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.Parameter")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.Parameter"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "x"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "literal"),+                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "string"),+                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+                                      Core.projectionFieldName = (Core.Name "description")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "isLazy"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "boolean"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.Parameter"),+                                      Core.projectionFieldName = (Core.Name "isLazy")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.Parameter")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.result"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.Result")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.Result"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermLambda (Core.Lambda {+                                              Core.lambdaParameter = (Core.Name "x"),+                                              Core.lambdaDomain = Nothing,+                                              Core.lambdaBody = (Core.TermInject (Core.Injection {+                                                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                                Core.injectionField = Core.Field {+                                                  Core.fieldName = (Core.Name "literal"),+                                                  Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                    Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                                    Core.injectionField = Core.Field {+                                                      Core.fieldName = (Core.Name "string"),+                                                      Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.Result"),+                                      Core.projectionFieldName = (Core.Name "description")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "type"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.Result"),+                                      Core.projectionFieldName = (Core.Name "type")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.Result")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.termSignature"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TermSignature")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TermSignature"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeParameters"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.typing.typeParameter"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+                                      Core.projectionFieldName = (Core.Name "typeParameters")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "parameters"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.typing.parameter"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+                                      Core.projectionFieldName = (Core.Name "parameters")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "result"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.typing.result")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TermSignature"),+                                      Core.projectionFieldName = (Core.Name "result")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TermSignature")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.termSubst"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TermSubst")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TermSubst"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "m"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "map"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.term"))})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typing.TermSubst")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TermSubst")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeClass"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeClass")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeClass"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "description"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TypeClass"),+                                      Core.projectionFieldName = (Core.Name "description")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeClass")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeConstraint"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeConstraint")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeConstraint"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "left"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+                                      Core.projectionFieldName = (Core.Name "left")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "right"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.type")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+                                      Core.projectionFieldName = (Core.Name "right")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "comment"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TypeConstraint"),+                                      Core.projectionFieldName = (Core.Name "comment")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeConstraint")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeParameter"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeParameter")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeParameter"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "name"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.encode.core.name")),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"),+                                      Core.projectionFieldName = (Core.Name "name")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "constraints"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "xs"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "list"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.typeClassConstraint"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.typing.TypeParameter"),+                                      Core.projectionFieldName = (Core.Name "constraints")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeParameter")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.typing.typeSubst"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.typing.TypeSubst")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.typing.TypeSubst"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "m"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "map"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.type"))})),+                                  Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.typing.TypeSubst")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.typing.TypeSubst")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Util.hs view
@@ -0,0 +1,703 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.util++module Hydra.Sources.Encode.Util where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.util"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.util"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.packaging"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.util"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.util.caseConvention"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.CaseConvention")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.util.CaseConvention"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "camel"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "camel"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pascal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pascal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "lowerSnake"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lowerSnake"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "upperSnake"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.CaseConvention"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "upperSnake"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.CaseConvention")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.util.comparison"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.Comparison")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.util.Comparison"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "lessThan"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Comparison"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lessThan"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "equalTo"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Comparison"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "equalTo"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "greaterThan"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Comparison"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "greaterThan"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.Comparison")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.util.fileExtension"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.FileExtension")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "wrap"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.WrappedTerm"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.FileExtension"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "body"),+                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                          Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                            Core.lambdaParameter = (Core.Name "x"),+                            Core.lambdaDomain = Nothing,+                            Core.lambdaBody = (Core.TermInject (Core.Injection {+                              Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                              Core.injectionField = Core.Field {+                                Core.fieldName = (Core.Name "literal"),+                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                  Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                  Core.injectionField = Core.Field {+                                    Core.fieldName = (Core.Name "string"),+                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                          Core.applicationArgument = (Core.TermApplication (Core.Application {+                            Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.util.FileExtension")),+                            Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.FileExtension")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.util.moduleNames"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "n"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "n")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.util.ModuleNames")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "n"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "n"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.ModuleNames"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "focus"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "p"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "pair"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.pairs.bimap")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "n"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "p"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"),+                                        Core.projectionFieldName = (Core.Name "focus")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "mapping"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "m"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "map"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermApplication (Core.Application {+                                                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.bimap")),+                                                Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName"))})),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "n"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "m"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.util.ModuleNames"),+                                        Core.projectionFieldName = (Core.Name "mapping")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.ModuleNames")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.util.precision"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.Precision")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.util.Precision"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "arbitrary"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Precision"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "arbitrary"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "bits"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.Precision"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "bits"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "x"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "literal"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "integer"),+                                                Core.fieldTerm = (Core.TermInject (Core.Injection {+                                                  Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                                  Core.injectionField = Core.Field {+                                                    Core.fieldName = (Core.Name "int32"),+                                                    Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.Precision")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.util.qualifiedName"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.util.QualifiedName")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.util.QualifiedName"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "moduleName"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "opt"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "optional"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.packaging.moduleName"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "opt"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"),+                                      Core.projectionFieldName = (Core.Name "moduleName")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "local"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "string"),+                                            Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.util.QualifiedName"),+                                      Core.projectionFieldName = (Core.Name "local")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (Core.TermVariable (Core.Name "description"), (Core.TermLiteral (Core.LiteralString "Encoder for hydra.util.QualifiedName")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Validation.hs view
@@ -0,0 +1,295 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.validation++module Hydra.Sources.Encode.Validation where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.validation"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.validation"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.error.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.validation"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.validation.validationProfile"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.validation.ValidationProfile")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermInject (Core.Injection {+                Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                Core.injectionField = Core.Field {+                  Core.fieldName = (Core.Name "record"),+                  Core.fieldTerm = (Core.TermRecord (Core.Record {+                    Core.recordTypeName = (Core.Name "hydra.core.Record"),+                    Core.recordFields = [+                      Core.Field {+                        Core.fieldName = (Core.Name "typeName"),+                        Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                          Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                          Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.validation.ValidationProfile"))}))},+                      Core.Field {+                        Core.fieldName = (Core.Name "fields"),+                        Core.fieldTerm = (Core.TermList [+                          Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "errorRules"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "s"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "set"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+                                      Core.projectionFieldName = (Core.Name "errorRules")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "warningRules"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "s"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "set"),+                                        Core.fieldTerm = (Core.TermApplication (Core.Application {+                                          Core.applicationFunction = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.map")),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "hydra.encode.core.name"))})),+                                          Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+                                      Core.projectionFieldName = (Core.Name "warningRules")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "maxErrors"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+                                      Core.projectionFieldName = (Core.Name "maxErrors")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]})),+                          (Core.TermRecord (Core.Record {+                            Core.recordTypeName = (Core.Name "hydra.core.Field"),+                            Core.recordFields = [+                              Core.Field {+                                Core.fieldName = (Core.Name "name"),+                                Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                  Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                  Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "maxWarnings"))}))},+                              Core.Field {+                                Core.fieldName = (Core.Name "term"),+                                Core.fieldTerm = (Core.TermApplication (Core.Application {+                                  Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                    Core.lambdaParameter = (Core.Name "x"),+                                    Core.lambdaDomain = Nothing,+                                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                      Core.injectionField = Core.Field {+                                        Core.fieldName = (Core.Name "literal"),+                                        Core.fieldTerm = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Literal"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "integer"),+                                            Core.fieldTerm = (Core.TermInject (Core.Injection {+                                              Core.injectionTypeName = (Core.Name "hydra.core.IntegerValue"),+                                              Core.injectionField = Core.Field {+                                                Core.fieldName = (Core.Name "int32"),+                                                Core.fieldTerm = (Core.TermVariable (Core.Name "x"))}}))}}))}}))})),+                                  Core.applicationArgument = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermProject (Core.Projection {+                                      Core.projectionTypeName = (Core.Name "hydra.validation.ValidationProfile"),+                                      Core.projectionFieldName = (Core.Name "maxWarnings")})),+                                    Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.validation.ValidationProfile")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.validation.validationResult"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [+              Typing.TypeParameter {+                Typing.typeParameterName = (Core.Name "e"),+                Typing.typeParameterConstraints = []}],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+                  Core.functionTypeDomain = (Core.TypeVariable (Core.Name "e")),+                  Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "hydra.core.Term"))})),+                Typing.parameterIsLazy = False},+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg1"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeApplication (Core.ApplicationType {+                  Core.applicationTypeFunction = (Core.TypeVariable (Core.Name "hydra.validation.ValidationResult")),+                  Core.applicationTypeArgument = (Core.TypeVariable (Core.Name "e"))})),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "e"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermLambda (Core.Lambda {+                Core.lambdaParameter = (Core.Name "x"),+                Core.lambdaDomain = Nothing,+                Core.lambdaBody = (Core.TermInject (Core.Injection {+                  Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                  Core.injectionField = Core.Field {+                    Core.fieldName = (Core.Name "record"),+                    Core.fieldTerm = (Core.TermRecord (Core.Record {+                      Core.recordTypeName = (Core.Name "hydra.core.Record"),+                      Core.recordFields = [+                        Core.Field {+                          Core.fieldName = (Core.Name "typeName"),+                          Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                            Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                            Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.validation.ValidationResult"))}))},+                        Core.Field {+                          Core.fieldName = (Core.Name "fields"),+                          Core.fieldTerm = (Core.TermList [+                            Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "errors"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "e"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"),+                                        Core.projectionFieldName = (Core.Name "errors")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}),+                            (Core.TermRecord (Core.Record {+                              Core.recordTypeName = (Core.Name "hydra.core.Field"),+                              Core.recordFields = [+                                Core.Field {+                                  Core.fieldName = (Core.Name "name"),+                                  Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                    Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                    Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "warnings"))}))},+                                Core.Field {+                                  Core.fieldName = (Core.Name "term"),+                                  Core.fieldTerm = (Core.TermApplication (Core.Application {+                                    Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.Name "xs"),+                                      Core.lambdaDomain = Nothing,+                                      Core.lambdaBody = (Core.TermInject (Core.Injection {+                                        Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                        Core.injectionField = Core.Field {+                                          Core.fieldName = (Core.Name "list"),+                                          Core.fieldTerm = (Core.TermApplication (Core.Application {+                                            Core.applicationFunction = (Core.TermApplication (Core.Application {+                                              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.map")),+                                              Core.applicationArgument = (Core.TermVariable (Core.Name "e"))})),+                                            Core.applicationArgument = (Core.TermVariable (Core.Name "xs"))}))}}))})),+                                    Core.applicationArgument = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermProject (Core.Projection {+                                        Core.projectionTypeName = (Core.Name "hydra.validation.ValidationResult"),+                                        Core.projectionFieldName = (Core.Name "warnings")})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}]}))])}]}))}}))}))})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.validation.ValidationResult")))]))}))}))]}
+ src/main/haskell/Hydra/Sources/Encode/Variants.hs view
@@ -0,0 +1,1812 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Source module for hydra.encode.variants++module Hydra.Sources.Encode.Variants where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Typing as Typing+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+module_ :: Packaging.Module+module_ =+    Packaging.Module {+      Packaging.moduleName = (Packaging.ModuleName "hydra.encode.variants"),+      Packaging.moduleMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Term encoders for hydra.variants"),+        Packaging.entityMetadataComments = [],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.moduleDependencies = [+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.encode.core"),+          Packaging.moduleDependencyPackage = Nothing},+        Packaging.ModuleDependency {+          Packaging.moduleDependencyModule = (Packaging.ModuleName "hydra.variants"),+          Packaging.moduleDependencyPackage = Nothing}],+      Packaging.moduleDefinitions = [+        Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.variants.literalVariant"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.variants.LiteralVariant")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.variants.LiteralVariant"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "binary"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "binary"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "boolean"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "boolean"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "decimal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "decimal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "float"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "float"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "integer"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "integer"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "string"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.LiteralVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "string"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.variants.LiteralVariant")))]))}))}),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.variants.termVariant"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.variants.TermVariant")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.variants.TermVariant"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "annotated"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "application"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "cases"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "cases"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "either"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "inject"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "inject"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "lambda"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "lambda"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "let"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "let"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "list"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "literal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "map"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "optional"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pair"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "project"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "project"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "record"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "set"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeApplication"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeApplication"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "typeLambda"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "typeLambda"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unit"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unwrap"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unwrap"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "variable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "wrap"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TermVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.variants.TermVariant")))]))}))})),+        (Packaging.DefinitionTerm (Packaging.TermDefinition {+          Packaging.termDefinitionName = (Core.Name "hydra.encode.variants.typeVariant"),+          Packaging.termDefinitionMetadata = Nothing,+          Packaging.termDefinitionSignature = (Just (Typing.TermSignature {+            Typing.termSignatureTypeParameters = [],+            Typing.termSignatureParameters = [+              Typing.Parameter {+                Typing.parameterName = (Core.Name "arg0"),+                Typing.parameterDescription = Nothing,+                Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.variants.TypeVariant")),+                Typing.parameterIsLazy = False}],+            Typing.termSignatureResult = Typing.Result {+              Typing.resultDescription = Nothing,+              Typing.resultType = (Core.TypeVariable (Core.Name "hydra.core.Term"))}})),+          Packaging.termDefinitionBody = (Core.TermAnnotated (Core.AnnotatedTerm {+            Core.annotatedTermBody = (Core.TermCases (Core.CaseStatement {+              Core.caseStatementTypeName = (Core.Name "hydra.variants.TypeVariant"),+              Core.caseStatementDefault = Nothing,+              Core.caseStatementCases = [+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "annotated"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "annotated"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "application"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "application"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "either"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "either"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "forall"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "forall"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "function"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "function"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "list"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "list"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "literal"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "literal"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "map"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "map"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "optional"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "optional"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "pair"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "pair"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "record"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "record"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "set"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "set"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "union"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "union"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "unit"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "unit"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "variable"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "variable"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "void"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "void"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))},+                Core.CaseAlternative {+                  Core.caseAlternativeName = (Core.Name "wrap"),+                  Core.caseAlternativeHandler = (Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.Name "y"),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.TermInject (Core.Injection {+                      Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                      Core.injectionField = Core.Field {+                        Core.fieldName = (Core.Name "inject"),+                        Core.fieldTerm = (Core.TermRecord (Core.Record {+                          Core.recordTypeName = (Core.Name "hydra.core.Injection"),+                          Core.recordFields = [+                            Core.Field {+                              Core.fieldName = (Core.Name "typeName"),+                              Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "hydra.variants.TypeVariant"))}))},+                            Core.Field {+                              Core.fieldName = (Core.Name "field"),+                              Core.fieldTerm = (Core.TermRecord (Core.Record {+                                Core.recordTypeName = (Core.Name "hydra.core.Field"),+                                Core.recordFields = [+                                  Core.Field {+                                    Core.fieldName = (Core.Name "name"),+                                    Core.fieldTerm = (Core.TermWrap (Core.WrappedTerm {+                                      Core.wrappedTermTypeName = (Core.Name "hydra.core.Name"),+                                      Core.wrappedTermBody = (Core.TermLiteral (Core.LiteralString "wrap"))}))},+                                  Core.Field {+                                    Core.fieldName = (Core.Name "term"),+                                    Core.fieldTerm = (Core.TermApplication (Core.Application {+                                      Core.applicationFunction = (Core.TermLambda (Core.Lambda {+                                        Core.lambdaParameter = (Core.Name "_"),+                                        Core.lambdaDomain = Nothing,+                                        Core.lambdaBody = (Core.TermInject (Core.Injection {+                                          Core.injectionTypeName = (Core.Name "hydra.core.Term"),+                                          Core.injectionField = Core.Field {+                                            Core.fieldName = (Core.Name "unit"),+                                            Core.fieldTerm = Core.TermUnit}}))})),+                                      Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}]}))}]}))}}))}))}]})),+            Core.annotatedTermAnnotation = (Core.TermMap (M.fromList [+              (+                Core.TermVariable (Core.Name "description"),+                (Core.TermLiteral (Core.LiteralString "Encoder for hydra.variants.TypeVariant")))]))}))}))]}
+ src/main/haskell/Hydra/Strip.hs view
@@ -0,0 +1,169 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Annotation and type stripping and normalization++module Hydra.Strip where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Strip type annotations from the top levels of a term+deannotateAndDetypeTerm :: Core.Term -> Core.Term+deannotateAndDetypeTerm t =+    case t of+      Core.TermAnnotated v0 -> deannotateAndDetypeTerm (Core.annotatedTermBody v0)+      Core.TermTypeApplication v0 -> deannotateAndDetypeTerm (Core.typeApplicationTermBody v0)+      Core.TermTypeLambda v0 -> deannotateAndDetypeTerm (Core.typeLambdaBody v0)+      _ -> t+-- | Strip all annotations (including System F type annotations) from the top levels of a term+deannotateTerm :: Core.Term -> Core.Term+deannotateTerm t =+    case t of+      Core.TermAnnotated v0 -> deannotateTerm (Core.annotatedTermBody v0)+      _ -> t+-- | Strip all annotations from a term+deannotateType :: Core.Type -> Core.Type+deannotateType t =+    case t of+      Core.TypeAnnotated v0 -> deannotateType (Core.annotatedTypeBody v0)+      _ -> t+-- | Strip any top-level type lambdas from a type, extracting the (possibly nested) type body+deannotateTypeParameters :: Core.Type -> Core.Type+deannotateTypeParameters t =+    case (deannotateType t) of+      Core.TypeForall v0 -> deannotateTypeParameters (Core.forallTypeBody v0)+      _ -> t+-- | Recursively strip all annotations from a type+deannotateTypeRecursive :: Core.Type -> Core.Type+deannotateTypeRecursive typ =++      let strip =+              \recurse -> \typ2 ->+                let rewritten = recurse typ2+                in case rewritten of+                  Core.TypeAnnotated v0 -> Core.annotatedTypeBody v0+                  _ -> rewritten+      in (Rewriting.rewriteType strip typ)+-- | Recursively strip all annotations from a type scheme+deannotateTypeSchemeRecursive :: Core.TypeScheme -> Core.TypeScheme+deannotateTypeSchemeRecursive ts =++      let vars = Core.typeSchemeVariables ts+          typ = Core.typeSchemeBody ts+          constraints = Core.typeSchemeConstraints ts+      in Core.TypeScheme {+        Core.typeSchemeVariables = vars,+        Core.typeSchemeBody = (deannotateTypeRecursive typ),+        Core.typeSchemeConstraints = constraints}+-- | Strip System F type annotations from the top levels of a term, but leave application-specific annotations intact+detypeTerm :: Core.Term -> Core.Term+detypeTerm t =+    case t of+      Core.TermAnnotated v0 ->+        let subj = Core.annotatedTermBody v0+            ann = Core.annotatedTermAnnotation v0+        in (Core.TermAnnotated (Core.AnnotatedTerm {+          Core.annotatedTermBody = (detypeTerm subj),+          Core.annotatedTermAnnotation = ann}))+      Core.TermTypeApplication v0 -> deannotateAndDetypeTerm (Core.typeApplicationTermBody v0)+      Core.TermTypeLambda v0 -> deannotateAndDetypeTerm (Core.typeLambdaBody v0)+      _ -> t+-- | Recursively remove term annotations, including within subterms+removeTermAnnotations :: Core.Term -> Core.Term+removeTermAnnotations term =++      let remove =+              \recurse -> \term2 ->+                let rewritten = recurse term2+                in case term2 of+                  Core.TermAnnotated v0 -> Core.annotatedTermBody v0+                  _ -> rewritten+      in (Rewriting.rewriteTerm remove term)+-- | Recursively remove type annotations, including within subtypes+removeTypeAnnotations :: Core.Type -> Core.Type+removeTypeAnnotations typ =++      let remove =+              \recurse -> \typ2 ->+                let rewritten = recurse typ2+                in case rewritten of+                  Core.TypeAnnotated v0 -> Core.annotatedTypeBody v0+                  _ -> rewritten+      in (Rewriting.rewriteType remove typ)+-- | Strip type annotations (TypeLambda, TypeApplication, binding type schemes) from terms while preserving lambda domain types and other annotations+removeTypeAnnotationsFromTerm :: Core.Term -> Core.Term+removeTypeAnnotationsFromTerm term =++      let strip =+              \recurse -> \term2 ->+                let rewritten = recurse term2+                    stripBinding =+                            \b -> Core.Binding {+                              Core.bindingName = (Core.bindingName b),+                              Core.bindingTerm = (Core.bindingTerm b),+                              Core.bindingTypeScheme = Nothing}+                in case rewritten of+                  Core.TermLet v0 -> Core.TermLet (Core.Let {+                    Core.letBindings = (Lists.map stripBinding (Core.letBindings v0)),+                    Core.letBody = (Core.letBody v0)})+                  Core.TermTypeApplication v0 -> Core.typeApplicationTermBody v0+                  Core.TermTypeLambda v0 -> Core.typeLambdaBody v0+                  _ -> rewritten+      in (Rewriting.rewriteTerm strip term)+-- | Strip type annotations from terms while preserving other annotations+removeTypesFromTerm :: Core.Term -> Core.Term+removeTypesFromTerm term =++      let strip =+              \recurse -> \term2 ->+                let rewritten = recurse term2+                    stripBinding =+                            \b -> Core.Binding {+                              Core.bindingName = (Core.bindingName b),+                              Core.bindingTerm = (Core.bindingTerm b),+                              Core.bindingTypeScheme = Nothing}+                in case rewritten of+                  Core.TermLambda v0 -> Core.TermLambda (Core.Lambda {+                    Core.lambdaParameter = (Core.lambdaParameter v0),+                    Core.lambdaDomain = Nothing,+                    Core.lambdaBody = (Core.lambdaBody v0)})+                  Core.TermLet v0 -> Core.TermLet (Core.Let {+                    Core.letBindings = (Lists.map stripBinding (Core.letBindings v0)),+                    Core.letBody = (Core.letBody v0)})+                  Core.TermTypeApplication v0 -> Core.typeApplicationTermBody v0+                  Core.TermTypeLambda v0 -> Core.typeLambdaBody v0+                  _ -> rewritten+      in (Rewriting.rewriteTerm strip term)+-- | Strip outer type lambda wrappers from a term, preserving type application wrappers and annotations+stripTypeLambdas :: Core.Term -> Core.Term+stripTypeLambdas t =+    case t of+      Core.TermAnnotated v0 ->+        let subj = Core.annotatedTermBody v0+            ann = Core.annotatedTermAnnotation v0+        in (Core.TermAnnotated (Core.AnnotatedTerm {+          Core.annotatedTermBody = (stripTypeLambdas subj),+          Core.annotatedTermAnnotation = ann}))+      Core.TermTypeLambda v0 -> stripTypeLambdas (Core.typeLambdaBody v0)+      _ -> t
+ src/main/haskell/Hydra/Substitution.hs view
@@ -0,0 +1,216 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Variable substitution in type and term expressions.++module Hydra.Substitution where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Compose two type substitutions+composeTypeSubst :: Typing.TypeSubst -> Typing.TypeSubst -> Typing.TypeSubst+composeTypeSubst s1 s2 =+    Logic.ifElse (Maps.null (Typing.unTypeSubst s1)) s2 (Logic.ifElse (Maps.null (Typing.unTypeSubst s2)) s1 (composeTypeSubstNonEmpty s1 s2))+-- | Compose a list of type substitutions+composeTypeSubstList :: [Typing.TypeSubst] -> Typing.TypeSubst+composeTypeSubstList = Lists.foldl composeTypeSubst idTypeSubst+-- | Compose two non-empty type substitutions (internal helper)+composeTypeSubstNonEmpty :: Typing.TypeSubst -> Typing.TypeSubst -> Typing.TypeSubst+composeTypeSubstNonEmpty s1 s2 =++      let isExtra = \k -> \v -> Optionals.isNone (Maps.lookup k (Typing.unTypeSubst s1))+          withExtra = Maps.filterWithKey isExtra (Typing.unTypeSubst s2)+      in (Typing.TypeSubst (Maps.union withExtra (Maps.map (substInType s2) (Typing.unTypeSubst s1))))+-- | The identity type substitution+idTypeSubst :: Typing.TypeSubst+idTypeSubst = Typing.TypeSubst Maps.empty+-- | Create a type substitution with a single variable mapping+singletonTypeSubst :: Core.Name -> Core.Type -> Typing.TypeSubst+singletonTypeSubst v t = Typing.TypeSubst (Maps.singleton v t)+-- | Apply a type substitution to class constraints, propagating to free variables+substInClassConstraints :: Typing.TypeSubst -> M.Map Core.Name Core.TypeVariableConstraints -> M.Map Core.Name Core.TypeVariableConstraints+substInClassConstraints subst constraints =++      let substMap = Typing.unTypeSubst subst+          insertOrMerge =+                  \varName -> \metadata -> \acc -> Optionals.cases (Maps.lookup varName acc) (Maps.insert varName metadata acc) (\existing ->+                    let merged =+                            Core.TypeVariableConstraints {+                              Core.typeVariableConstraintsClasses = (Lists.nub (Lists.concat2 (Core.typeVariableConstraintsClasses existing) (Core.typeVariableConstraintsClasses metadata)))}+                    in (Maps.insert varName merged acc))+      in (Lists.foldl (\acc -> \pair ->+        let varName = Pairs.first pair+            metadata = Pairs.second pair+        in (Optionals.cases (Maps.lookup varName substMap) (insertOrMerge varName metadata acc) (\targetType ->+          let freeVars = Sets.toList (Variables.freeVariablesInType targetType)+          in (Lists.foldl (\acc2 -> \freeVar -> insertOrMerge freeVar metadata acc2) acc freeVars)))) Maps.empty (Maps.toList constraints))+-- | Apply a type substitution to a graph's bound types and class constraints+substInContext :: Typing.TypeSubst -> Graph.Graph -> Graph.Graph+substInContext subst cx =++      let newBoundTypes = Maps.map (substInTypeScheme subst) (Graph.graphBoundTypes cx)+          newClassConstraints = substInClassConstraints subst (Graph.graphClassConstraints cx)+          cx2 =+                  Graph.Graph {+                    Graph.graphBoundTerms = (Graph.graphBoundTerms cx),+                    Graph.graphBoundTypes = newBoundTypes,+                    Graph.graphClassConstraints = (Graph.graphClassConstraints cx),+                    Graph.graphLambdaVariables = (Graph.graphLambdaVariables cx),+                    Graph.graphMetadata = (Graph.graphMetadata cx),+                    Graph.graphPrimitives = (Graph.graphPrimitives cx),+                    Graph.graphSchemaTypes = (Graph.graphSchemaTypes cx),+                    Graph.graphTypeVariables = (Graph.graphTypeVariables cx)}+      in Graph.Graph {+        Graph.graphBoundTerms = (Graph.graphBoundTerms cx2),+        Graph.graphBoundTypes = (Graph.graphBoundTypes cx2),+        Graph.graphClassConstraints = newClassConstraints,+        Graph.graphLambdaVariables = (Graph.graphLambdaVariables cx2),+        Graph.graphMetadata = (Graph.graphMetadata cx2),+        Graph.graphPrimitives = (Graph.graphPrimitives cx2),+        Graph.graphSchemaTypes = (Graph.graphSchemaTypes cx2),+        Graph.graphTypeVariables = (Graph.graphTypeVariables cx2)}+-- | Apply a type substitution to a type+substInType :: Typing.TypeSubst -> Core.Type -> Core.Type+substInType subst typ0 = Logic.ifElse (Maps.null (Typing.unTypeSubst subst)) typ0 (substInTypeNonEmpty subst typ0)+-- | Apply a non-empty type substitution to a type (internal helper)+substInTypeNonEmpty :: Typing.TypeSubst -> Core.Type -> Core.Type+substInTypeNonEmpty subst typ0 =++      let rewrite =+              \recurse -> \typ -> case typ of+                Core.TypeForall v0 -> Optionals.cases (Maps.lookup (Core.forallTypeParameter v0) (Typing.unTypeSubst subst)) (recurse typ) (\styp -> Core.TypeForall (Core.ForallType {+                  Core.forallTypeParameter = (Core.forallTypeParameter v0),+                  Core.forallTypeBody = (substInType (removeVar (Core.forallTypeParameter v0)) (Core.forallTypeBody v0))}))+                Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 (Typing.unTypeSubst subst)) typ (\styp -> styp)+                _ -> recurse typ+          removeVar = \v -> Typing.TypeSubst (Maps.delete v (Typing.unTypeSubst subst))+      in (Rewriting.rewriteType rewrite typ0)+-- | Apply a type substitution to a type scheme. The scheme's quantifier variables shadow the substitution: any name in typeSchemeVariables is removed from subst before substituting into the body and constraints. Without this, a substitution like {t0 -> Foo} applied to `forall [t0]. t0 -> t0` would incorrectly replace the bound t0.+substInTypeScheme :: Typing.TypeSubst -> Core.TypeScheme -> Core.TypeScheme+substInTypeScheme subst ts =++      let scopedSubst =+              Typing.TypeSubst (Lists.foldl (\m -> \v -> Maps.delete v m) (Typing.unTypeSubst subst) (Core.typeSchemeVariables ts))+      in Core.TypeScheme {+        Core.typeSchemeVariables = (Core.typeSchemeVariables ts),+        Core.typeSchemeBody = (substInType scopedSubst (Core.typeSchemeBody ts)),+        Core.typeSchemeConstraints = (Optionals.map (substInClassConstraints scopedSubst) (Core.typeSchemeConstraints ts))}+-- | Apply a type substitution to the type annotations within a term+substTypesInTerm :: Typing.TypeSubst -> Core.Term -> Core.Term+substTypesInTerm subst term0 =++      let rewrite =+              \recurse -> \term ->+                let dflt = recurse term+                    forLambda =+                            \l -> Core.TermLambda (Core.Lambda {+                              Core.lambdaParameter = (Core.lambdaParameter l),+                              Core.lambdaDomain = (Optionals.map (substInType subst) (Core.lambdaDomain l)),+                              Core.lambdaBody = (substTypesInTerm subst (Core.lambdaBody l))})+                    forLet =+                            \l ->+                              let rewriteBinding =+                                      \b -> Core.Binding {+                                        Core.bindingName = (Core.bindingName b),+                                        Core.bindingTerm = (substTypesInTerm subst (Core.bindingTerm b)),+                                        Core.bindingTypeScheme = (Optionals.map (substInTypeScheme subst) (Core.bindingTypeScheme b))}+                              in (Core.TermLet (Core.Let {+                                Core.letBindings = (Lists.map rewriteBinding (Core.letBindings l)),+                                Core.letBody = (substTypesInTerm subst (Core.letBody l))}))+                    forTypeApplication =+                            \tt -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                              Core.typeApplicationTermBody = (substTypesInTerm subst (Core.typeApplicationTermBody tt)),+                              Core.typeApplicationTermType = (substInType subst (Core.typeApplicationTermType tt))})+                    forTypeLambda =+                            \ta ->+                              let param = Core.typeLambdaParameter ta+                                  subst2 = Typing.TypeSubst (Maps.delete param (Typing.unTypeSubst subst))+                              in (Core.TermTypeLambda (Core.TypeLambda {+                                Core.typeLambdaParameter = param,+                                Core.typeLambdaBody = (substTypesInTerm subst2 (Core.typeLambdaBody ta))}))+                in case term of+                  Core.TermLambda v0 -> forLambda v0+                  Core.TermLet v0 -> forLet v0+                  Core.TermTypeApplication v0 -> forTypeApplication v0+                  Core.TermTypeLambda v0 -> forTypeLambda v0+                  _ -> dflt+      in (Rewriting.rewriteTerm rewrite term0)+-- | Apply a term substitution to a binding+substituteInBinding :: Typing.TermSubst -> Core.Binding -> Core.Binding+substituteInBinding subst b =+    Core.Binding {+      Core.bindingName = (Core.bindingName b),+      Core.bindingTerm = (substituteInTerm subst (Core.bindingTerm b)),+      Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+-- | Apply a type substitution to a type constraint+substituteInConstraint :: Typing.TypeSubst -> Typing.TypeConstraint -> Typing.TypeConstraint+substituteInConstraint subst c =+    Typing.TypeConstraint {+      Typing.typeConstraintLeft = (substInType subst (Typing.typeConstraintLeft c)),+      Typing.typeConstraintRight = (substInType subst (Typing.typeConstraintRight c)),+      Typing.typeConstraintComment = (Typing.typeConstraintComment c)}+-- | Apply a type substitution to a list of type constraints+substituteInConstraints :: Typing.TypeSubst -> [Typing.TypeConstraint] -> [Typing.TypeConstraint]+substituteInConstraints subst cs = Lists.map (substituteInConstraint subst) cs+-- | Apply a term substitution to a term+substituteInTerm :: Typing.TermSubst -> Core.Term -> Core.Term+substituteInTerm subst term0 =++      let s = Typing.unTermSubst subst+          rewrite =+                  \recurse -> \term ->+                    let withLambda =+                            \l ->+                              let v = Core.lambdaParameter l+                                  subst2 = Typing.TermSubst (Maps.delete v s)+                              in (Core.TermLambda (Core.Lambda {+                                Core.lambdaParameter = v,+                                Core.lambdaDomain = (Core.lambdaDomain l),+                                Core.lambdaBody = (substituteInTerm subst2 (Core.lambdaBody l))}))+                        withLet =+                                \lt ->+                                  let bindings = Core.letBindings lt+                                      names = Sets.fromList (Lists.map Core.bindingName bindings)+                                      subst2 = Typing.TermSubst (Maps.filterWithKey (\k -> \v -> Logic.not (Sets.member k names)) s)+                                      rewriteBinding =+                                              \b -> Core.Binding {+                                                Core.bindingName = (Core.bindingName b),+                                                Core.bindingTerm = (substituteInTerm subst2 (Core.bindingTerm b)),+                                                Core.bindingTypeScheme = (Core.bindingTypeScheme b)}+                                  in (Core.TermLet (Core.Let {+                                    Core.letBindings = (Lists.map rewriteBinding bindings),+                                    Core.letBody = (substituteInTerm subst2 (Core.letBody lt))}))+                    in case term of+                      Core.TermLambda v0 -> withLambda v0+                      Core.TermLet v0 -> withLet v0+                      Core.TermVariable v0 -> Optionals.cases (Maps.lookup v0 s) (recurse term) (\sterm -> sterm)+                      _ -> recurse term+      in (Rewriting.rewriteTerm rewrite term0)
+ src/main/haskell/Hydra/Tabular.hs view
@@ -0,0 +1,49 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A simple, untyped tabular data model, suitable for CSVs and TSVs++module Hydra.Tabular where+import qualified Hydra.Core as Core+import qualified Hydra.Relational as Relational+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | A column type, consisting of a name and a value type+data ColumnType =+  ColumnType {+    columnTypeName :: Relational.ColumnName,+    columnTypeType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_ColumnType = Core.Name "hydra.tabular.ColumnType"+_ColumnType_name = Core.Name "name"+_ColumnType_type = Core.Name "type"+-- | A data row, containing optional-valued cells; one per column+newtype DataRow v =+  DataRow {+    unDataRow :: [Maybe v]}+  deriving (Eq, Ord, Read, Show)+_DataRow = Core.Name "hydra.tabular.DataRow"+-- | A header row, containing column names (but no types or data)+newtype HeaderRow =+  HeaderRow {+    unHeaderRow :: [String]}+  deriving (Eq, Ord, Read, Show)+_HeaderRow = Core.Name "hydra.tabular.HeaderRow"+-- | A simple table as in a CSV file, having an optional header row and any number of data rows+data Table v =+  Table {+    -- | The optional header row of the table. If present, the header must have the same number of cells as each data row.+    tableHeader :: (Maybe HeaderRow),+    -- | The data rows of the table. Each row must have the same number of cells.+    tableData :: [DataRow v]}+  deriving (Eq, Ord, Read, Show)+_Table = Core.Name "hydra.tabular.Table"+_Table_header = Core.Name "header"+_Table_data = Core.Name "data"+-- | A type definition for a table, including column names and types+data TableType =+  TableType {+    tableTypeName :: Relational.RelationName,+    tableTypeColumns :: [ColumnType]}+  deriving (Eq, Ord, Read, Show)+_TableType = Core.Name "hydra.tabular.TableType"+_TableType_name = Core.Name "name"+_TableType_columns = Core.Name "columns"
+ src/main/haskell/Hydra/Templates.hs view
@@ -0,0 +1,109 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A utility which instantiates a nonrecursive type with default values++module Hydra.Templates where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Decode.Core as DecodeCore+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Hydra.Haskell.Lib.Literals as Literals+-- | Decode a list of type-encoding bindings into a map of named types+graphToSchema :: t0 -> Graph.Graph -> [Core.Binding] -> Either Errors.DecodingError (M.Map Core.Name Core.Type)+graphToSchema cx graph els =++      let toPair =+              \el ->+                let name = Core.bindingName el+                in (Eithers.bind (DecodeCore.type_ graph (Core.bindingTerm el)) (\t -> Right (name, t)))+      in (Eithers.bind (Eithers.mapList toPair els) (\pairs -> Right (Maps.fromList pairs)))+-- | Given a graph schema and a nonrecursive type, instantiate it with default values. If the minimal flag is set, the smallest possible term is produced; otherwise, exactly one subterm is produced for constructors which do not otherwise require one, e.g. in lists and optionals. The name parameter provides the element name for nominal type construction.+instantiateTemplate :: t0 -> Bool -> M.Map Core.Name Core.Type -> Core.Name -> Core.Type -> Either Errors.Error Core.Term+instantiateTemplate cx minimal schema tname t =++      let inst = \tn -> instantiateTemplate cx minimal schema tn+          noPoly =+                  Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+                    Errors.unexpectedShapeErrorExpected = "non-polymorphic type",+                    Errors.unexpectedShapeErrorActual = "polymorphic or function type"})))+          forFloat =+                  \ft -> case ft of+                    Core.FloatTypeFloat32 -> Core.FloatValueFloat32 0.0+                    Core.FloatTypeFloat64 -> Core.FloatValueFloat64 0.0+          forInteger =+                  \it -> case it of+                    Core.IntegerTypeBigint -> Core.IntegerValueBigint 0+                    Core.IntegerTypeInt8 -> Core.IntegerValueInt8 0+                    Core.IntegerTypeInt16 -> Core.IntegerValueInt16 0+                    Core.IntegerTypeInt32 -> Core.IntegerValueInt32 0+                    Core.IntegerTypeInt64 -> Core.IntegerValueInt64 0+                    Core.IntegerTypeUint8 -> Core.IntegerValueUint8 0+                    Core.IntegerTypeUint16 -> Core.IntegerValueUint16 0+                    Core.IntegerTypeUint32 -> Core.IntegerValueUint32 0+                    Core.IntegerTypeUint64 -> Core.IntegerValueUint64 0+          forLiteral =+                  \lt -> case lt of+                    Core.LiteralTypeBinary -> Core.LiteralString ""+                    Core.LiteralTypeBoolean -> Core.LiteralBoolean False+                    Core.LiteralTypeDecimal -> Core.LiteralDecimal (Literals.stringToDecimal "0.0")+                    Core.LiteralTypeInteger v0 -> Core.LiteralInteger (forInteger v0)+                    Core.LiteralTypeFloat v0 -> Core.LiteralFloat (forFloat v0)+                    Core.LiteralTypeString -> Core.LiteralString ""+      in case t of+        Core.TypeAnnotated v0 -> inst tname (Core.annotatedTypeBody v0)+        Core.TypeApplication _ -> noPoly+        Core.TypeFunction _ -> noPoly+        Core.TypeForall _ -> noPoly+        Core.TypeList v0 -> Logic.ifElse minimal (Right (Core.TermList [])) (Eithers.bind (inst tname v0) (\e -> Right (Core.TermList [+          e])))+        Core.TypeLiteral v0 -> Right (Core.TermLiteral (forLiteral v0))+        Core.TypeMap v0 ->+          let kt = Core.mapTypeKeys v0+              vt = Core.mapTypeValues v0+          in (Logic.ifElse minimal (Right (Core.TermMap Maps.empty)) (Eithers.bind (inst tname kt) (\ke -> Eithers.bind (inst tname vt) (\ve -> Right (Core.TermMap (Maps.singleton ke ve))))))+        Core.TypeOptional v0 -> Logic.ifElse minimal (Right (Core.TermOptional Nothing)) (Eithers.bind (inst tname v0) (\e -> Right (Core.TermOptional (Just e))))+        Core.TypeRecord v0 ->+          let toField =+                  \ft -> Eithers.bind (inst tname (Core.fieldTypeType ft)) (\e -> Right (Core.Field {+                    Core.fieldName = (Core.fieldTypeName ft),+                    Core.fieldTerm = e}))+          in (Eithers.bind (Eithers.mapList toField v0) (\dfields -> Right (Core.TermRecord (Core.Record {+            Core.recordTypeName = tname,+            Core.recordFields = dfields}))))+        Core.TypeSet v0 -> Logic.ifElse minimal (Right (Core.TermSet Sets.empty)) (Eithers.bind (inst tname v0) (\e -> Right (Core.TermSet (Sets.fromList [+          e]))))+        Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 schema) (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+          Errors.unexpectedShapeErrorExpected = "bound type variable",+          Errors.unexpectedShapeErrorActual = (Strings.cat2 "unbound variable " (Core.unName v0))})))) (inst v0)+        Core.TypeWrap v0 -> Eithers.bind (inst tname v0) (\e -> Right (Core.TermWrap (Core.WrappedTerm {+          Core.wrappedTermTypeName = tname,+          Core.wrappedTermBody = e})))
+ src/main/haskell/Hydra/Test/Transform.hs view
@@ -0,0 +1,120 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Transform test cases for code generation, filtering to tests that can be compiled to target languages++module Hydra.Test.Transform where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Sorting as Sorting+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Add generation namespace prefix+addGenerationPrefix :: Packaging.ModuleName -> Packaging.ModuleName+addGenerationPrefix ns_ = Packaging.ModuleName (Strings.cat2 "generation." (Packaging.unModuleName ns_))+-- | Build a Term representing a convertCase function call+buildConvertCaseCall :: Util.CaseConvention -> Util.CaseConvention -> String -> Core.Term+buildConvertCaseCall fromConv toConv input_ =+    Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.convertCase")),+          Core.applicationArgument = (encodeCaseConvention fromConv)})),+        Core.applicationArgument = (encodeCaseConvention toConv)})),+      Core.applicationArgument = (Core.TermLiteral (Core.LiteralString input_))})+-- | Build a Term representing a topologicalSort function call+buildTopologicalSortCall :: [(Int, [Int])] -> Core.Term+buildTopologicalSortCall adjList =+    Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.topologicalSort")),+      Core.applicationArgument = (encodeAdjacencyList adjList)})+-- | Build a Term representing a topologicalSortComponents function call+buildTopologicalSortSCCCall :: [(Int, [Int])] -> Core.Term+buildTopologicalSortSCCCall adjList =+    Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.sorting.topologicalSortComponents")),+      Core.applicationArgument = (encodeAdjacencyList adjList)})+-- | Collect all test cases from a test group (flattening hierarchy)+collectTestCases :: Testing.TestGroup -> [Testing.TestCaseWithMetadata]+collectTestCases tg =+    Lists.concat2 (Testing.testGroupCases tg) (Lists.concat (Lists.map (\sg -> collectTestCases sg) (Testing.testGroupSubgroups tg)))+-- | Encode an adjacency list as a Term+encodeAdjacencyList :: [(Int, [Int])] -> Core.Term+encodeAdjacencyList pairs =+    Core.TermList (Lists.map (\p -> Core.TermPair (encodeInt (Pairs.first p), (Core.TermList (Lists.map (\d -> encodeInt d) (Pairs.second p))))) pairs)+-- | Encode CaseConvention as a Term (unit variant)+encodeCaseConvention :: Util.CaseConvention -> Core.Term+encodeCaseConvention conv =+    Core.TermInject (Core.Injection {+      Core.injectionTypeName = (Core.Name "hydra.util.CaseConvention"),+      Core.injectionField = Core.Field {+        Core.fieldName = case conv of+          Util.CaseConventionLowerSnake -> Core.Name "lowerSnake"+          Util.CaseConventionUpperSnake -> Core.Name "upperSnake"+          Util.CaseConventionCamel -> Core.Name "camel"+          Util.CaseConventionPascal -> Core.Name "pascal",+        Core.fieldTerm = Core.TermUnit}})+-- | Encode Either [[Int]] [Int] as a Term+encodeEitherListList :: Either [[Int]] [Int] -> Core.Term+encodeEitherListList e =+    Core.TermEither (Eithers.bimap (\cycles -> encodeListList cycles) (\sorted -> encodeIntList sorted) e)+-- | Encode an Int as a Term+encodeInt :: Int -> Core.Term+encodeInt n = Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 n))+-- | Encode [Int] as a Term+encodeIntList :: [Int] -> Core.Term+encodeIntList ints = Core.TermList (Lists.map (\n -> encodeInt n) ints)+-- | Encode [[Int]] as a Term+encodeListList :: [[Int]] -> Core.Term+encodeListList lists = Core.TermList (Lists.map (\l -> encodeIntList l) lists)+-- | Transform module with generation namespace+transformModule :: Packaging.Module -> Packaging.Module+transformModule m =+    Packaging.Module {+      Packaging.moduleName = (addGenerationPrefix (Packaging.moduleName m)),+      Packaging.moduleMetadata = (Packaging.moduleMetadata m),+      Packaging.moduleDependencies = (Packaging.moduleDependencies m),+      Packaging.moduleDefinitions = (Packaging.moduleDefinitions m)}+-- | Pass through test cases unchanged+transformTestCase :: t0 -> Maybe t0+transformTestCase tcm = Just tcm+-- | Transform test group hierarchy to only include delegated evaluation tests+transformToCompiledTests :: Testing.TestGroup -> Maybe Testing.TestGroup+transformToCompiledTests tg =++      let name_ = Testing.testGroupName tg+          desc = Testing.testGroupDescription tg+          subgroups = Testing.testGroupSubgroups tg+          cases_ = Testing.testGroupCases tg+          transformedCases = Optionals.cat (Lists.map (\tc -> transformTestCase tc) cases_)+          transformedSubgroups = Optionals.cat (Lists.map (\sg -> transformToCompiledTests sg) subgroups)+      in (Logic.ifElse (Logic.and (Lists.null transformedCases) (Lists.null transformedSubgroups)) Nothing (Just (Testing.TestGroup {+        Testing.testGroupName = name_,+        Testing.testGroupDescription = desc,+        Testing.testGroupSubgroups = transformedSubgroups,+        Testing.testGroupCases = transformedCases})))
+ src/main/haskell/Hydra/Test/Utils.hs view
@@ -0,0 +1,62 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Shared utility functions for test code generation codecs++module Hydra.Test.Utils where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Inference as Inference+import qualified Hydra.Json.Model as Model+import qualified Hydra.Lexical as Lexical+import qualified Hydra.Haskell.Lib.Eithers as Eithers+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Show.Errors as ShowErrors+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Run type inference on a single term+inferTerm :: Graph.Graph -> Core.Term -> Either String Core.Term+inferTerm g term =+    Eithers.bimap (\e -> ShowErrors.error e) (\x -> Typing.inferenceResultTerm x) (Inference.inferInGraphContext Lexical.emptyInferenceContext g term)+-- | Run type inference on the terms in a test case+inferTestCase :: t0 -> Testing.TestCaseWithMetadata -> Either t1 Testing.TestCaseWithMetadata+inferTestCase g tcm =++      let name_ = Testing.testCaseWithMetadataName tcm+          tcase = Testing.testCaseWithMetadataCase tcm+          desc = Testing.testCaseWithMetadataDescription tcm+          tags_ = Testing.testCaseWithMetadataTags tcm+      in (Eithers.map (\inferredCase -> Testing.TestCaseWithMetadata {+        Testing.testCaseWithMetadataName = name_,+        Testing.testCaseWithMetadataCase = inferredCase,+        Testing.testCaseWithMetadataDescription = desc,+        Testing.testCaseWithMetadataTags = tags_}) (Right tcase))+-- | Run type inference on all terms in a TestGroup to ensure lambdas have domain types+inferTestGroupTerms :: t0 -> Testing.TestGroup -> Either t1 Testing.TestGroup+inferTestGroupTerms g tg =++      let name_ = Testing.testGroupName tg+          desc = Testing.testGroupDescription tg+          subgroups = Testing.testGroupSubgroups tg+          cases_ = Testing.testGroupCases tg+      in (Eithers.bind (Eithers.mapList (\sg -> inferTestGroupTerms g sg) subgroups) (\inferredSubgroups -> Eithers.map (\inferredCases -> Testing.TestGroup {+        Testing.testGroupName = name_,+        Testing.testGroupDescription = desc,+        Testing.testGroupSubgroups = inferredSubgroups,+        Testing.testGroupCases = inferredCases}) (Eithers.mapList (\tc -> inferTestCase g tc) cases_)))
+ src/main/haskell/Hydra/Testing.hs view
@@ -0,0 +1,61 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A model for unit testing++module Hydra.Testing where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | A tag for test cases+newtype Tag =+  Tag {+    unTag :: String}+  deriving (Eq, Ord, Read, Show)+_Tag = Core.Name "hydra.testing.Tag"+-- | A test case with an actual and expected string for comparison+data TestCase =+  -- | A universal test case (string comparison)+  TestCaseUniversal UniversalTestCase+_TestCase = Core.Name "hydra.testing.TestCase"+_TestCase_universal = Core.Name "universal"+-- | A test case together with metadata+data TestCaseWithMetadata =+  TestCaseWithMetadata {+    -- | A short name for the test case+    testCaseWithMetadataName :: String,+    -- | The test case itself+    testCaseWithMetadataCase :: TestCase,+    -- | An optional longer description of the test case+    testCaseWithMetadataDescription :: (Maybe String),+    -- | Zero or more tags for the test case+    testCaseWithMetadataTags :: [Tag]}+_TestCaseWithMetadata = Core.Name "hydra.testing.TestCaseWithMetadata"+_TestCaseWithMetadata_name = Core.Name "name"+_TestCaseWithMetadata_case = Core.Name "case"+_TestCaseWithMetadata_description = Core.Name "description"+_TestCaseWithMetadata_tags = Core.Name "tags"+-- | A collection of test cases with a name and optional description+data TestGroup =+  TestGroup {+    -- | A short name for the test group+    testGroupName :: String,+    -- | An optional longer description of the test group+    testGroupDescription :: (Maybe String),+    -- | Zero or more subgroups+    testGroupSubgroups :: [TestGroup],+    -- | Zero or more test cases+    testGroupCases :: [TestCaseWithMetadata]}+_TestGroup = Core.Name "hydra.testing.TestGroup"+_TestGroup_name = Core.Name "name"+_TestGroup_description = Core.Name "description"+_TestGroup_subgroups = Core.Name "subgroups"+_TestGroup_cases = Core.Name "cases"+-- | A universal test case: the actual and expected values are thunks producing strings.+data UniversalTestCase =+  UniversalTestCase {+    -- | A thunk producing the actual result string. Wrapping in a thunk defers expression evaluation until the test runner forces it, so eagerly-evaluated hosts measure expression cost inside their timing bracket rather than at test-data load time.+    universalTestCaseActual :: (() -> String),+    -- | A thunk producing the expected result string.+    universalTestCaseExpected :: (() -> String)}+_UniversalTestCase = Core.Name "hydra.testing.UniversalTestCase"+_UniversalTestCase_actual = Core.Name "actual"+_UniversalTestCase_expected = Core.Name "expected"
+ src/main/haskell/Hydra/Topology.hs view
@@ -0,0 +1,48 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A model for simple graphs as adjacency lists++module Hydra.Topology where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | A directed graph represented as an adjacency list mapping vertices to their outgoing neighbors+type Graph = (M.Map Vertex [Vertex])+_Graph = Core.Name "hydra.topology.Graph"+-- | A pair of inverse permutations on lists, used to relate two orderings of the same elements+data OrderingIsomorphism a =+  OrderingIsomorphism {+    -- | Mapping from source ordering to target ordering+    orderingIsomorphismEncode :: ([a] -> [a]),+    -- | Mapping from target ordering to source ordering+    orderingIsomorphismDecode :: ([a] -> [a])}+_OrderingIsomorphism = Core.Name "hydra.topology.OrderingIsomorphism"+_OrderingIsomorphism_encode = Core.Name "encode"+_OrderingIsomorphism_decode = Core.Name "decode"+-- | State carried by Tarjan's strongly connected components algorithm during a depth-first traversal+data TarjanState =+  TarjanState {+    -- | Next available index for vertices in the DFS traversal+    tarjanStateCounter :: Int,+    -- | Mapping from vertices to their indices in the DFS traversal+    tarjanStateIndices :: (M.Map Vertex Int),+    -- | Mapping from vertices to their lowest reachable index in the DFS traversal+    tarjanStateLowLinks :: (M.Map Vertex Int),+    -- | Current DFS stack, with vertices in reverse order+    tarjanStateStack :: [Vertex],+    -- | Set of vertices currently on the stack, for quick lookup+    tarjanStateOnStack :: (S.Set Vertex),+    -- | Accumulated strongly connected components, each a list of vertices+    tarjanStateSccs :: [[Vertex]]}+  deriving (Eq, Ord, Read, Show)+_TarjanState = Core.Name "hydra.topology.TarjanState"+_TarjanState_counter = Core.Name "counter"+_TarjanState_indices = Core.Name "indices"+_TarjanState_lowLinks = Core.Name "lowLinks"+_TarjanState_stack = Core.Name "stack"+_TarjanState_onStack = Core.Name "onStack"+_TarjanState_sccs = Core.Name "sccs"+-- | A graph vertex, represented as a 32-bit integer identifier+type Vertex = Int+_Vertex = Core.Name "hydra.topology.Vertex"
+ src/main/haskell/Hydra/Typed.hs view
@@ -0,0 +1,35 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Typed (phantom) wrappers for use with Hydra DSLs++module Hydra.Typed where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | An association of a named term (element) with a phantom type+data TypedBinding a =+  TypedBinding {+    -- | The name of the term+    typedBindingName :: Core.Name,+    -- | The term with its phantom type+    typedBindingTerm :: (TypedTerm a)}+  deriving (Eq, Ord, Read, Show)+_TypedBinding = Core.Name "hydra.typed.TypedBinding"+_TypedBinding_name = Core.Name "name"+_TypedBinding_term = Core.Name "term"+-- | An association of a term with a phantom type+newtype TypedTerm a =+  TypedTerm {+    unTypedTerm :: Core.Term}+  deriving (Eq, Ord, Read, Show)+_TypedTerm = Core.Name "hydra.typed.TypedTerm"+-- | An association of a term definition with a phantom type+data TypedTermDefinition a =+  TypedTermDefinition {+    -- | The name of the term+    typedTermDefinitionName :: Core.Name,+    -- | The term with its phantom type+    typedTermDefinitionTerm :: (TypedTerm a)}+  deriving (Eq, Ord, Read, Show)+_TypedTermDefinition = Core.Name "hydra.typed.TypedTermDefinition"+_TypedTermDefinition_name = Core.Name "name"+_TypedTermDefinition_term = Core.Name "term"
+ src/main/haskell/Hydra/Typing.hs view
@@ -0,0 +1,153 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Types supporting type inference and type reconstruction.++module Hydra.Typing where+import qualified Hydra.Core as Core+import qualified Hydra.Paths as Paths+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | A structured representation of a function term's components, replacing ad-hoc tuples. This captures all the information extracted from peeling lambdas, type lambdas, lets, and type applications from a term.+data FunctionStructure env =+  FunctionStructure {+    -- | Type parameters (from type lambdas)+    functionStructureTypeParams :: [Core.Name],+    -- | Value parameters (from lambdas)+    functionStructureParams :: [Core.Name],+    -- | Let bindings accumulated from the term+    functionStructureBindings :: [Core.Binding],+    -- | The body term after removing all lambdas, lets, etc.+    functionStructureBody :: Core.Term,+    -- | Domain types of the value parameters+    functionStructureDomains :: [Core.Type],+    -- | The return type of the function (if type inference succeeded)+    functionStructureCodomain :: (Maybe Core.Type),+    -- | Updated environment after processing all bindings+    functionStructureEnvironment :: env}+  deriving (Eq, Ord, Read, Show)+_FunctionStructure = Core.Name "hydra.typing.FunctionStructure"+_FunctionStructure_typeParams = Core.Name "typeParams"+_FunctionStructure_params = Core.Name "params"+_FunctionStructure_bindings = Core.Name "bindings"+_FunctionStructure_body = Core.Name "body"+_FunctionStructure_domains = Core.Name "domains"+_FunctionStructure_codomain = Core.Name "codomain"+_FunctionStructure_environment = Core.Name "environment"+-- | State threaded through type inference: the fresh type variable counter and the current subterm-path trace.+data InferenceContext =+  InferenceContext {+    -- | Counter used to generate distinct fresh type variables during inference+    inferenceContextFreshTypeVariableCount :: Int,+    -- | The current subterm-path trace, accumulated backwards (head = most-recently-pushed step, corresponding to the deepest point in the descent). At the moment an inference error is constructed, the list is reversed and wrapped into a SubtermPath (root-to-leaf order) and stamped onto the error.+    inferenceContextTrace :: [Paths.SubtermStep]}+  deriving (Eq, Ord, Read, Show)+_InferenceContext = Core.Name "hydra.typing.InferenceContext"+_InferenceContext_freshTypeVariableCount = Core.Name "freshTypeVariableCount"+_InferenceContext_trace = Core.Name "trace"+-- | The result of applying inference rules to a term.+data InferenceResult =+  InferenceResult {+    -- | The term which was inferred+    inferenceResultTerm :: Core.Term,+    -- | The inferred type of the term+    inferenceResultType :: Core.Type,+    -- | The type substitution resulting from unification+    inferenceResultSubst :: TypeSubst,+    -- | Class constraints discovered during inference (e.g., Ord constraints from Map.lookup)+    inferenceResultClassConstraints :: (M.Map Core.Name Core.TypeVariableConstraints),+    -- | The updated InferenceContext after inference (carries fresh-variable counter and trace)+    inferenceResultContext :: InferenceContext}+  deriving (Eq, Ord, Read, Show)+_InferenceResult = Core.Name "hydra.typing.InferenceResult"+_InferenceResult_term = Core.Name "term"+_InferenceResult_type = Core.Name "type"+_InferenceResult_subst = Core.Name "subst"+_InferenceResult_classConstraints = Core.Name "classConstraints"+_InferenceResult_context = Core.Name "context"+-- | A named, typed parameter of a term, with optional human-readable description and a flag indicating whether the parameter requires lazy evaluation by hosts which support it.+data Parameter =+  Parameter {+    -- | The name of the parameter+    parameterName :: Core.Name,+    -- | An optional human-readable description of the parameter+    parameterDescription :: (Maybe String),+    -- | The type of the parameter+    parameterType :: Core.Type,+    -- | Whether the parameter must be passed lazily (thunked) at call sites in hosts that distinguish strict from lazy evaluation+    parameterIsLazy :: Bool}+  deriving (Eq, Ord, Read, Show)+_Parameter = Core.Name "hydra.typing.Parameter"+_Parameter_name = Core.Name "name"+_Parameter_description = Core.Name "description"+_Parameter_type = Core.Name "type"+_Parameter_isLazy = Core.Name "isLazy"+-- | The result of a term, consisting of a type and an optional human-readable description.+data Result =+  Result {+    -- | An optional human-readable description of the result+    resultDescription :: (Maybe String),+    -- | The type of the result+    resultType :: Core.Type}+  deriving (Eq, Ord, Read, Show)+_Result = Core.Name "hydra.typing.Result"+_Result_description = Core.Name "description"+_Result_type = Core.Name "type"+-- | A structured signature for a term: an ordered list of type parameters (with optional class constraints), an ordered list of value parameters, and a result. TermSignature is a richer view of TypeScheme: every TermSignature can be converted to a TypeScheme by erasing parameter names, descriptions, and laziness flags.+data TermSignature =+  TermSignature {+    -- | The type parameters of the term, in order+    termSignatureTypeParameters :: [TypeParameter],+    -- | The value parameters of the term, in order+    termSignatureParameters :: [Parameter],+    -- | The result of the term+    termSignatureResult :: Result}+  deriving (Eq, Ord, Read, Show)+_TermSignature = Core.Name "hydra.typing.TermSignature"+_TermSignature_typeParameters = Core.Name "typeParameters"+_TermSignature_parameters = Core.Name "parameters"+_TermSignature_result = Core.Name "result"+-- | A substitution of term variables for terms+newtype TermSubst =+  TermSubst {+    unTermSubst :: (M.Map Core.Name Core.Term)}+  deriving (Eq, Ord, Read, Show)+_TermSubst = Core.Name "hydra.typing.TermSubst"+-- | A type class identifier together with a human-readable description. Type classes are referenced as bare names (e.g. the local name "equality") in TypeVariableConstraints.classes; the canonical definitions live as term bindings under hydra.classes.+data TypeClass =+  TypeClass {+    -- | A human-readable description of the type class+    typeClassDescription :: String}+  deriving (Eq, Ord, Read, Show)+_TypeClass = Core.Name "hydra.typing.TypeClass"+_TypeClass_description = Core.Name "description"+-- | An assertion that two types can be unified into a single type+data TypeConstraint =+  TypeConstraint {+    -- | The left-hand side of the constraint+    typeConstraintLeft :: Core.Type,+    -- | The right-hand side of the constraint+    typeConstraintRight :: Core.Type,+    -- | A description of the type constraint which may be used for tracing or debugging+    typeConstraintComment :: String}+  deriving (Eq, Ord, Read, Show)+_TypeConstraint = Core.Name "hydra.typing.TypeConstraint"+_TypeConstraint_left = Core.Name "left"+_TypeConstraint_right = Core.Name "right"+_TypeConstraint_comment = Core.Name "comment"+-- | A type parameter of a term, with an optional list of type class constraints+data TypeParameter =+  TypeParameter {+    -- | The name of the type parameter+    typeParameterName :: Core.Name,+    -- | Any type class constraints on the type parameter+    typeParameterConstraints :: [Core.TypeClassConstraint]}+  deriving (Eq, Ord, Read, Show)+_TypeParameter = Core.Name "hydra.typing.TypeParameter"+_TypeParameter_name = Core.Name "name"+_TypeParameter_constraints = Core.Name "constraints"+-- | A substitution of type variables for types+newtype TypeSubst =+  TypeSubst {+    unTypeSubst :: (M.Map Core.Name Core.Type)}+  deriving (Eq, Ord, Read, Show)+_TypeSubst = Core.Name "hydra.typing.TypeSubst"
+ src/main/haskell/Hydra/Unification.hs view
@@ -0,0 +1,186 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Utilities for type unification.++module Hydra.Unification where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Show.Core as ShowCore+import qualified Hydra.Strip as Strip+import qualified Hydra.Substitution as Substitution+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | Join two types, producing a list of type constraints.The comment is used to provide context for the constraints.+joinTypes :: t0 -> Core.Type -> Core.Type -> String -> Either Errors.UnificationError [Typing.TypeConstraint]+joinTypes cx left right comment =++      let sleft = Strip.deannotateType left+          sright = Strip.deannotateType right+          joinOne =+                  \l -> \r -> Typing.TypeConstraint {+                    Typing.typeConstraintLeft = l,+                    Typing.typeConstraintRight = r,+                    Typing.typeConstraintComment = (Strings.cat2 "join types; " comment)}+          cannotUnify =+                  Left (Errors.UnificationError {+                    Errors.unificationErrorLeftType = sleft,+                    Errors.unificationErrorRightType = sright,+                    Errors.unificationErrorMessage = (Strings.cat2 (Strings.cat2 (Strings.cat2 "cannot unify " (ShowCore.type_ sleft)) " with ") (ShowCore.type_ sright))})+          assertEqual = Logic.ifElse (Equality.equal sleft sright) (Right []) cannotUnify+          joinList =+                  \lefts -> \rights -> Logic.ifElse (Equality.equal (Lists.length lefts) (Lists.length rights)) (Right (Lists.zipWith joinOne lefts rights)) cannotUnify+          joinRowTypes =+                  \left2 -> \right2 -> Logic.ifElse (Logic.and (Equality.equal (Lists.length (Lists.map Core.fieldTypeName left2)) (Lists.length (Lists.map Core.fieldTypeName right2))) (Lists.foldl Logic.and True (Lists.zipWith (\left3 -> \right3 -> Equality.equal (Core.unName left3) (Core.unName right3)) (Lists.map Core.fieldTypeName left2) (Lists.map Core.fieldTypeName right2)))) (joinList (Lists.map Core.fieldTypeType left2) (Lists.map Core.fieldTypeType right2)) cannotUnify+      in case sleft of+        Core.TypeApplication v0 -> case sright of+          Core.TypeApplication v1 -> Right [+            joinOne (Core.applicationTypeFunction v0) (Core.applicationTypeFunction v1),+            (joinOne (Core.applicationTypeArgument v0) (Core.applicationTypeArgument v1))]+          _ -> cannotUnify+        Core.TypeEither v0 -> case sright of+          Core.TypeEither v1 -> Right [+            joinOne (Core.eitherTypeLeft v0) (Core.eitherTypeLeft v1),+            (joinOne (Core.eitherTypeRight v0) (Core.eitherTypeRight v1))]+          _ -> cannotUnify+        Core.TypeFunction v0 -> case sright of+          Core.TypeFunction v1 -> Right [+            joinOne (Core.functionTypeDomain v0) (Core.functionTypeDomain v1),+            (joinOne (Core.functionTypeCodomain v0) (Core.functionTypeCodomain v1))]+          _ -> cannotUnify+        Core.TypeList v0 -> case sright of+          Core.TypeList v1 -> Right [+            joinOne v0 v1]+          _ -> cannotUnify+        Core.TypeLiteral _ -> assertEqual+        Core.TypeMap v0 -> case sright of+          Core.TypeMap v1 -> Right [+            joinOne (Core.mapTypeKeys v0) (Core.mapTypeKeys v1),+            (joinOne (Core.mapTypeValues v0) (Core.mapTypeValues v1))]+          _ -> cannotUnify+        Core.TypeOptional v0 -> case sright of+          Core.TypeOptional v1 -> Right [+            joinOne v0 v1]+          _ -> cannotUnify+        Core.TypePair v0 -> case sright of+          Core.TypePair v1 -> Right [+            joinOne (Core.pairTypeFirst v0) (Core.pairTypeFirst v1),+            (joinOne (Core.pairTypeSecond v0) (Core.pairTypeSecond v1))]+          _ -> cannotUnify+        Core.TypeRecord v0 -> case sright of+          Core.TypeRecord v1 -> joinRowTypes v0 v1+          _ -> cannotUnify+        Core.TypeSet v0 -> case sright of+          Core.TypeSet v1 -> Right [+            joinOne v0 v1]+          _ -> cannotUnify+        Core.TypeUnion v0 -> case sright of+          Core.TypeUnion v1 -> joinRowTypes v0 v1+          _ -> cannotUnify+        Core.TypeUnit -> case sright of+          Core.TypeUnit -> Right []+          _ -> cannotUnify+        Core.TypeVoid -> case sright of+          Core.TypeVoid -> Right []+          _ -> cannotUnify+        Core.TypeWrap v0 -> case sright of+          Core.TypeWrap v1 -> Right [+            joinOne v0 v1]+          _ -> cannotUnify+        _ -> cannotUnify+-- | Robinson's algorithm, following https://www.cs.cornell.edu/courses/cs6110/2017sp/lectures/lec23.pdf+-- | Specifically this is an implementation of the following rules:+-- |   * Unify({(x, t)} ∪ E) = {t/x} Unify(E{t/x}) if x ∉ FV(t)+-- |   * Unify(∅) = I (the identity substitution x ↦ x)+-- |   * Unify({(x, x)} ∪ E) = Unify(E)+-- |   * Unify({(f(s1, ..., sn), f(t1, ..., tn))} ∪ E) = Unify({(s1, t1), ..., (sn, tn)} ∪ E))+unifyTypeConstraints :: t0 -> M.Map Core.Name t1 -> [Typing.TypeConstraint] -> Either Errors.UnificationError Typing.TypeSubst+unifyTypeConstraints cx schemaTypes constraints =++      let withConstraint =+              \c -> \rest ->+                let sleft = Strip.deannotateType (Typing.typeConstraintLeft c)+                    sright = Strip.deannotateType (Typing.typeConstraintRight c)+                    comment = Typing.typeConstraintComment c+                    bind =+                            \v -> \t ->+                              let subst = Substitution.singletonTypeSubst v t+                                  withResult = \s -> Substitution.composeTypeSubst subst s+                              in (Eithers.map withResult (unifyTypeConstraints cx schemaTypes (Substitution.substituteInConstraints subst rest)))+                    tryBinding =+                            \v -> \t -> Logic.ifElse (variableOccursInType v t) (Left (Errors.UnificationError {+                              Errors.unificationErrorLeftType = sleft,+                              Errors.unificationErrorRightType = sright,+                              Errors.unificationErrorMessage = (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "Variable " (Core.unName v)) " appears free in type ") (ShowCore.type_ t)) " (") comment) ")")})) (bind v t)+                    noVars =++                              let withConstraints = \constraints2 -> unifyTypeConstraints cx schemaTypes (Lists.concat2 constraints2 rest)+                              in (Eithers.bind (joinTypes cx sleft sright comment) withConstraints)+                    dflt =+                            case sright of+                              Core.TypeVariable v0 -> tryBinding v0 sleft+                              _ -> noVars+                in case sleft of+                  Core.TypeVariable v0 -> case sright of+                    Core.TypeVariable v1 -> Logic.ifElse (Equality.equal (Core.unName v0) (Core.unName v1)) (unifyTypeConstraints cx schemaTypes rest) (Logic.ifElse (Optionals.isGiven (Maps.lookup v0 schemaTypes)) (Logic.ifElse (Optionals.isGiven (Maps.lookup v1 schemaTypes)) (Left (Errors.UnificationError {+                      Errors.unificationErrorLeftType = sleft,+                      Errors.unificationErrorRightType = sright,+                      Errors.unificationErrorMessage = (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 (Strings.cat2 "Attempted to unify schema names " (Core.unName v0)) " and ") (Core.unName v1)) " (") comment) ")")})) (bind v1 sleft)) (bind v0 sright))+                    _ -> tryBinding v0 sright+                  _ -> dflt+      in (Optionals.cases (Lists.uncons constraints) (Right Substitution.idTypeSubst) (\uc -> withConstraint (Pairs.first uc) (Pairs.second uc)))+-- | Unify two lists of types pairwise, producing a single substitution that satisfies every pair. The lists must have the same length; the comment is attached to each generated constraint for diagnostics.+unifyTypeLists :: t0 -> M.Map Core.Name t1 -> [Core.Type] -> [Core.Type] -> String -> Either Errors.UnificationError Typing.TypeSubst+unifyTypeLists cx schemaTypes l r comment =++      let toConstraint =+              \l2 -> \r2 -> Typing.TypeConstraint {+                Typing.typeConstraintLeft = l2,+                Typing.typeConstraintRight = r2,+                Typing.typeConstraintComment = comment}+      in (unifyTypeConstraints cx schemaTypes (Lists.zipWith toConstraint l r))+-- | Unify two types, producing a substitution that makes them equal (or an error). The comment is attached to the generated constraint for diagnostics.+unifyTypes :: t0 -> M.Map Core.Name t1 -> Core.Type -> Core.Type -> String -> Either Errors.UnificationError Typing.TypeSubst+unifyTypes cx schemaTypes l r comment =+    unifyTypeConstraints cx schemaTypes [+      Typing.TypeConstraint {+        Typing.typeConstraintLeft = l,+        Typing.typeConstraintRight = r,+        Typing.typeConstraintComment = comment}]+-- | Determine whether a type variable appears within a type expression.No distinction is made between free and bound type variables.+variableOccursInType :: Core.Name -> Core.Type -> Bool+variableOccursInType var typ0 =++      let tryType =+              \b -> \typ -> case typ of+                Core.TypeVariable v0 -> Logic.or b (Equality.equal (Core.unName v0) (Core.unName var))+                _ -> b+      in (Rewriting.foldOverType Coders.TraversalOrderPre tryType False typ0)
+ src/main/haskell/Hydra/Util.hs view
@@ -0,0 +1,69 @@+-- Note: this is an automatically generated file. Do not edit.+-- | General-purpose utility types used across Hydra.++module Hydra.Util where+import qualified Hydra.Core as Core+import qualified Hydra.Packaging as Packaging+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | A naming convention for symbols, such as camelCase or snake_case+data CaseConvention =+  CaseConventionCamel |+  CaseConventionPascal |+  CaseConventionLowerSnake |+  CaseConventionUpperSnake+  deriving (Eq, Ord, Read, Show)+_CaseConvention = Core.Name "hydra.util.CaseConvention"+_CaseConvention_camel = Core.Name "camel"+_CaseConvention_pascal = Core.Name "pascal"+_CaseConvention_lowerSnake = Core.Name "lowerSnake"+_CaseConvention_upperSnake = Core.Name "upperSnake"+-- | An equality judgement: less than, equal to, or greater than+data Comparison =+  ComparisonLessThan |+  ComparisonEqualTo |+  ComparisonGreaterThan+  deriving (Eq, Ord, Read, Show)+_Comparison = Core.Name "hydra.util.Comparison"+_Comparison_lessThan = Core.Name "lessThan"+_Comparison_equalTo = Core.Name "equalTo"+_Comparison_greaterThan = Core.Name "greaterThan"+-- | A file extension (without the dot), e.g. "json" or "py"+newtype FileExtension =+  FileExtension {+    unFileExtension :: String}+  deriving (Eq, Ord, Read, Show)+_FileExtension = Core.Name "hydra.util.FileExtension"+-- | A mapping from module names to values of type n, with a focus on one module name+data ModuleNames n =+  ModuleNames {+    -- | The module name in focus, together with its associated value+    moduleNamesFocus :: (Packaging.ModuleName, n),+    -- | A mapping of module names to values+    moduleNamesMapping :: (M.Map Packaging.ModuleName n)}+  deriving (Eq, Ord, Read, Show)+_ModuleNames = Core.Name "hydra.util.ModuleNames"+_ModuleNames_focus = Core.Name "focus"+_ModuleNames_mapping = Core.Name "mapping"+-- | Numeric precision: arbitrary precision, or precision to a specified number of bits+data Precision =+  -- | Arbitrary precision+  PrecisionArbitrary |+  -- | Precision to a specified number of bits+  PrecisionBits Int+  deriving (Eq, Ord, Read, Show)+_Precision = Core.Name "hydra.util.Precision"+_Precision_arbitrary = Core.Name "arbitrary"+_Precision_bits = Core.Name "bits"+-- | A qualified name consisting of an optional module name together with a mandatory local name+data QualifiedName =+  QualifiedName {+    -- | The optional module name+    qualifiedNameModuleName :: (Maybe Packaging.ModuleName),+    -- | The local name+    qualifiedNameLocal :: String}+  deriving (Eq, Ord, Read, Show)+_QualifiedName = Core.Name "hydra.util.QualifiedName"+_QualifiedName_moduleName = Core.Name "moduleName"+_QualifiedName_local = Core.Name "local"
+ src/main/haskell/Hydra/Validate/Core.hs view
@@ -0,0 +1,444 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Validation functions for core terms and types++module Hydra.Validate.Core where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Equality as Equality+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+import qualified Hydra.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Haskell.Lib.Pairs as Pairs+import qualified Hydra.Haskell.Lib.Sets as Sets+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Reflect as Reflect+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variables as Variables+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | Append a rule-tagged InvalidTermError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds.+appendFinding :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0+appendFinding p acc finding =+    Optionals.cases finding acc (\rp ->+      let ruleName = Pairs.first rp+          payload = Pairs.second rp+          errs = Validation.validationResultErrors acc+          wrns = Validation.validationResultWarnings acc+      in (Logic.ifElse (Sets.member ruleName (Validation.validationProfileErrorRules p)) (Logic.ifElse (Equality.lt (Lists.length errs) (Validation.validationProfileMaxErrors p)) (Validation.ValidationResult {+        Validation.validationResultErrors = (Lists.concat2 errs (Lists.singleton payload)),+        Validation.validationResultWarnings = wrns}) acc) (Logic.ifElse (Sets.member ruleName (Validation.validationProfileWarningRules p)) (Logic.ifElse (Equality.lt (Lists.length wrns) (Validation.validationProfileMaxWarnings p)) (Validation.ValidationResult {+        Validation.validationResultErrors = errs,+        Validation.validationResultWarnings = (Lists.concat2 wrns (Lists.singleton payload))}) acc) acc)))+-- | Append a rule-tagged InvalidTypeError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds.+appendFindingType :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0+appendFindingType p acc finding =+    Optionals.cases finding acc (\rp ->+      let ruleName = Pairs.first rp+          payload = Pairs.second rp+          errs = Validation.validationResultErrors acc+          wrns = Validation.validationResultWarnings acc+      in (Logic.ifElse (Sets.member ruleName (Validation.validationProfileErrorRules p)) (Logic.ifElse (Equality.lt (Lists.length errs) (Validation.validationProfileMaxErrors p)) (Validation.ValidationResult {+        Validation.validationResultErrors = (Lists.concat2 errs (Lists.singleton payload)),+        Validation.validationResultWarnings = wrns}) acc) (Logic.ifElse (Sets.member ruleName (Validation.validationProfileWarningRules p)) (Logic.ifElse (Equality.lt (Lists.length wrns) (Validation.validationProfileMaxWarnings p)) (Validation.ValidationResult {+        Validation.validationResultErrors = errs,+        Validation.validationResultWarnings = (Lists.concat2 wrns (Lists.singleton payload))}) acc) acc)))+-- | Check for duplicate binding names in a list of bindings+checkDuplicateBindings :: Paths.SubtermPath -> [Core.Binding] -> Maybe ErrorCore.InvalidTermError+checkDuplicateBindings path bindings =++      let names = Lists.map Core.bindingName bindings+          dup = findDuplicate names+      in (Optionals.map (\name -> ErrorCore.InvalidTermErrorDuplicateBinding (ErrorCore.DuplicateBindingError {+        ErrorCore.duplicateBindingErrorLocation = path,+        ErrorCore.duplicateBindingErrorName = name})) dup)+-- | Check for duplicate field names in a list of field types+checkDuplicateFieldTypes :: [Core.FieldType] -> (Core.Name -> Maybe t0) -> Maybe t0+checkDuplicateFieldTypes fields mkError =++      let names = Lists.map Core.fieldTypeName fields+          dup = findDuplicateFieldType names+      in (Optionals.cases dup Nothing (\name -> mkError name))+-- | Check for duplicate field names in a list of fields+checkDuplicateFields :: Paths.SubtermPath -> [Core.Name] -> Maybe ErrorCore.InvalidTermError+checkDuplicateFields path names =++      let dup = findDuplicate names+      in (Optionals.map (\name -> ErrorCore.InvalidTermErrorDuplicateField (ErrorCore.DuplicateFieldError {+        ErrorCore.duplicateFieldErrorLocation = path,+        ErrorCore.duplicateFieldErrorName = name})) dup)+-- | Check that a literal value's type matches an expected literal type+checkLiteral :: Core.LiteralType -> Core.Literal -> Maybe ErrorCore.InvalidLiteralError+checkLiteral expected value =++      let actual = Reflect.literalType value+      in (Logic.ifElse (Equality.equal expected actual) Nothing (Just (ErrorCore.InvalidLiteralErrorTypeMismatch (ErrorCore.LiteralTypeMismatchError {+        ErrorCore.literalTypeMismatchErrorExpectedType = expected,+        ErrorCore.literalTypeMismatchErrorActualType = actual}))))+-- | Check if any name in a list shadows a variable already in scope+checkShadowing :: Paths.SubtermPath -> Graph.Graph -> [Core.Name] -> Maybe ErrorCore.InvalidTermError+checkShadowing path cx names =++      let result =+              Lists.foldl (\acc -> \name -> Optionals.cases acc (Logic.ifElse (Logic.or (Optionals.isGiven (Maps.lookup name (Graph.graphBoundTerms cx))) (Sets.member name (Graph.graphLambdaVariables cx))) (Just (ErrorCore.InvalidTermErrorTermVariableShadowing (ErrorCore.TermVariableShadowingError {+                ErrorCore.termVariableShadowingErrorLocation = path,+                ErrorCore.termVariableShadowingErrorName = name}))) Nothing) (\_ -> acc)) Nothing names+      in result+-- | Check a single term node for validation errors. Rules disabled by the profile are not evaluated.+checkTerm :: Validation.ValidationProfile -> Bool -> Paths.SubtermPath -> Graph.Graph -> Core.Term -> Maybe (Core.Name, ErrorCore.InvalidTermError)+checkTerm p typed path cx term =+    case term of+      Core.TermAnnotated v0 ->+        let body = Core.annotatedTermBody v0+            annMap = Annotations.getAnnotationMap (Core.annotatedTermAnnotation v0)+        in (firstFinding [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTermAnnotation")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTermAnnotation", f)) (Logic.ifElse (Maps.null annMap) (Just (ErrorCore.InvalidTermErrorEmptyTermAnnotation (ErrorCore.EmptyTermAnnotationError {+            ErrorCore.emptyTermAnnotationErrorLocation = path}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nestedTermAnnotation")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nestedTermAnnotation", f)) (case body of+            Core.TermAnnotated _ -> Just (ErrorCore.InvalidTermErrorNestedTermAnnotation (ErrorCore.NestedTermAnnotationError {+              ErrorCore.nestedTermAnnotationErrorLocation = path}))+            _ -> Nothing)) Nothing)])+      Core.TermApplication v0 ->+        let fun = Core.applicationFunction v0+            arg = Core.applicationArgument v0+        in (firstFinding [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.constantCondition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.constantCondition", f)) (case fun of+            Core.TermVariable v1 -> Logic.ifElse (Equality.equal (Core.unName v1) "hydra.lib.logic.ifElse") (case arg of+              Core.TermLiteral v2 -> case v2 of+                Core.LiteralBoolean v3 -> Just (ErrorCore.InvalidTermErrorConstantCondition (ErrorCore.ConstantConditionError {+                  ErrorCore.constantConditionErrorLocation = path,+                  ErrorCore.constantConditionErrorValue = v3}))+                _ -> Nothing+              _ -> Nothing) Nothing+            _ -> Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.selfApplication")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.selfApplication", f)) (case fun of+            Core.TermVariable v1 -> case arg of+              Core.TermVariable v2 -> Logic.ifElse (Equality.equal v1 v2) (Just (ErrorCore.InvalidTermErrorSelfApplication (ErrorCore.SelfApplicationError {+                ErrorCore.selfApplicationErrorLocation = path,+                ErrorCore.selfApplicationErrorName = v1}))) Nothing+              _ -> Nothing+            _ -> Nothing)) Nothing),+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unnecessaryIdentityApplication")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unnecessaryIdentityApplication", f)) (case fun of+            Core.TermLambda v1 ->+              let param = Core.lambdaParameter v1+                  body = Core.lambdaBody v1+              in case body of+                Core.TermVariable v2 -> Logic.ifElse (Equality.equal param v2) (Just (ErrorCore.InvalidTermErrorUnnecessaryIdentityApplication (ErrorCore.UnnecessaryIdentityApplicationError {+                  ErrorCore.unnecessaryIdentityApplicationErrorLocation = path}))) Nothing+                _ -> Nothing+            _ -> Nothing)) Nothing),+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.redundantWrapUnwrap")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.redundantWrapUnwrap", f)) (case fun of+            Core.TermUnwrap v1 -> case arg of+              Core.TermWrap v2 ->+                let wrapName = Core.wrappedTermTypeName v2+                in (Logic.ifElse (Equality.equal v1 wrapName) (Just (ErrorCore.InvalidTermErrorRedundantWrapUnwrap (ErrorCore.RedundantWrapUnwrapError {+                  ErrorCore.redundantWrapUnwrapErrorLocation = path,+                  ErrorCore.redundantWrapUnwrapErrorTypeName = v1}))) Nothing)+              _ -> Nothing+            _ -> Nothing)) Nothing)])+      Core.TermRecord v0 ->+        let tname = Core.recordTypeName v0+            flds = Core.recordFields v0+        in (firstFinding [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {+            ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.duplicateField")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.duplicateField", f)) (checkDuplicateFields path (Lists.map Core.fieldName flds))) Nothing)])+      Core.TermLet v0 ->+        let bindings = Core.letBindings v0+            names = Lists.map Core.bindingName bindings+        in (firstFinding [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyLetBindings")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyLetBindings", f)) (Logic.ifElse (Lists.null bindings) (Just (ErrorCore.InvalidTermErrorEmptyLetBindings (ErrorCore.EmptyLetBindingsError {+            ErrorCore.emptyLetBindingsErrorLocation = path}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.duplicateBinding")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.duplicateBinding", f)) (checkDuplicateBindings path bindings)) Nothing),+          Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.invalidLetBindingName")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.invalidLetBindingName", f)) (firstError (Lists.map (\bname -> Logic.ifElse (isValidName bname) Nothing (Just (ErrorCore.InvalidTermErrorInvalidLetBindingName (ErrorCore.InvalidLetBindingNameError {+            ErrorCore.invalidLetBindingNameErrorLocation = path,+            ErrorCore.invalidLetBindingNameErrorName = bname})))) names))) Nothing),+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInBindingType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInBindingType", f)) (Logic.ifElse typed (firstError (Lists.map (\b -> Optionals.cases (Core.bindingTypeScheme b) Nothing (\ts -> checkUndefinedTypeVariablesInTypeScheme path cx ts (\uvName -> Just (ErrorCore.InvalidTermErrorUndefinedTypeVariableInBindingType (ErrorCore.UndefinedTypeVariableInBindingTypeError {+            ErrorCore.undefinedTypeVariableInBindingTypeErrorLocation = path,+            ErrorCore.undefinedTypeVariableInBindingTypeErrorName = uvName}))))) bindings)) Nothing)) Nothing)])+      Core.TermInject v0 ->+        let tname = Core.injectionTypeName v0+        in (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {+          ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing)+      Core.TermLambda v0 ->+        let paramName = Core.lambdaParameter v0+        in (firstFinding [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.termVariableShadowing")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.termVariableShadowing", f)) (Logic.ifElse (Optionals.isGiven (Maps.lookup paramName (Graph.graphBoundTerms cx))) (Just (ErrorCore.InvalidTermErrorTermVariableShadowing (ErrorCore.TermVariableShadowingError {+            ErrorCore.termVariableShadowingErrorLocation = path,+            ErrorCore.termVariableShadowingErrorName = paramName}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.invalidLambdaParameterName")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.invalidLambdaParameterName", f)) (Logic.ifElse (isValidName paramName) Nothing (Just (ErrorCore.InvalidTermErrorInvalidLambdaParameterName (ErrorCore.InvalidLambdaParameterNameError {+            ErrorCore.invalidLambdaParameterNameErrorLocation = path,+            ErrorCore.invalidLambdaParameterNameErrorName = paramName}))))) Nothing),+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInLambdaDomain")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInLambdaDomain", f)) (Logic.ifElse typed (Optionals.cases (Core.lambdaDomain v0) Nothing (\dom -> checkUndefinedTypeVariablesInType path cx dom (\uvName -> Just (ErrorCore.InvalidTermErrorUndefinedTypeVariableInLambdaDomain (ErrorCore.UndefinedTypeVariableInLambdaDomainError {+            ErrorCore.undefinedTypeVariableInLambdaDomainErrorLocation = path,+            ErrorCore.undefinedTypeVariableInLambdaDomainErrorName = uvName}))))) Nothing)) Nothing)])+      Core.TermProject v0 ->+        let tname = Core.projectionTypeName v0+        in (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {+          ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing)+      Core.TermCases v0 ->+        let tname = Core.caseStatementTypeName v0+            csDefault = Core.caseStatementDefault v0+            csCases = Core.caseStatementCases v0+        in (firstFinding [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {+            ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyCaseStatement")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyCaseStatement", f)) (Logic.ifElse (Logic.and (Lists.null csCases) (Optionals.isNone csDefault)) (Just (ErrorCore.InvalidTermErrorEmptyCaseStatement (ErrorCore.EmptyCaseStatementError {+            ErrorCore.emptyCaseStatementErrorLocation = path,+            ErrorCore.emptyCaseStatementErrorTypeName = tname}))) Nothing)) Nothing),+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.duplicateField")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.duplicateField", f)) (checkDuplicateFields path (Lists.map Core.caseAlternativeName csCases))) Nothing)])+      Core.TermTypeApplication v0 -> Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInTypeApplication")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInTypeApplication", f)) (Logic.ifElse typed (checkUndefinedTypeVariablesInType path cx (Core.typeApplicationTermType v0) (\uvName -> Just (ErrorCore.InvalidTermErrorUndefinedTypeVariableInTypeApplication (ErrorCore.UndefinedTypeVariableInTypeApplicationError {+        ErrorCore.undefinedTypeVariableInTypeApplicationErrorLocation = path,+        ErrorCore.undefinedTypeVariableInTypeApplicationErrorName = uvName})))) Nothing)) Nothing+      Core.TermTypeLambda v0 ->+        let tvName = Core.typeLambdaParameter v0+        in (firstFinding [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.typeVariableShadowingInTypeLambda")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.typeVariableShadowingInTypeLambda", f)) (Logic.ifElse (Sets.member tvName (Sets.delete tvName (Graph.graphTypeVariables cx))) (Just (ErrorCore.InvalidTermErrorTypeVariableShadowingInTypeLambda (ErrorCore.TypeVariableShadowingInTypeLambdaError {+            ErrorCore.typeVariableShadowingInTypeLambdaErrorLocation = path,+            ErrorCore.typeVariableShadowingInTypeLambdaErrorName = tvName}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.invalidTypeLambdaParameterName")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.invalidTypeLambdaParameterName", f)) (Logic.ifElse (isValidName tvName) Nothing (Just (ErrorCore.InvalidTermErrorInvalidTypeLambdaParameterName (ErrorCore.InvalidTypeLambdaParameterNameError {+            ErrorCore.invalidTypeLambdaParameterNameErrorLocation = path,+            ErrorCore.invalidTypeLambdaParameterNameErrorName = tvName}))))) Nothing)])+      Core.TermVariable v0 -> Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTermVariable")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTermVariable", f)) (Logic.ifElse (Logic.or (Optionals.isGiven (Maps.lookup v0 (Graph.graphBoundTerms cx))) (Logic.or (Sets.member v0 (Graph.graphLambdaVariables cx)) (Optionals.isGiven (Maps.lookup v0 (Graph.graphPrimitives cx))))) Nothing (Just (ErrorCore.InvalidTermErrorUndefinedTermVariable (ErrorCore.UndefinedTermVariableError {+        ErrorCore.undefinedTermVariableErrorLocation = path,+        ErrorCore.undefinedTermVariableErrorName = v0}))))) Nothing+      Core.TermWrap v0 ->+        let tname = Core.wrappedTermTypeName v0+        in (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {+          ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing)+      _ -> Nothing+-- | Check a type for type variables not bound in the current scope+checkUndefinedTypeVariablesInType :: t0 -> Graph.Graph -> Core.Type -> (Core.Name -> Maybe t1) -> Maybe t1+checkUndefinedTypeVariablesInType path cx typ mkError =++      let freeVars = Variables.freeVariablesInType typ+          undefined = Sets.difference freeVars (Graph.graphTypeVariables cx)+      in (Optionals.cases (Lists.maybeHead (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined))+-- | Check a type scheme for type variables not bound by the scheme or the current scope+checkUndefinedTypeVariablesInTypeScheme :: t0 -> Graph.Graph -> Core.TypeScheme -> (Core.Name -> Maybe t1) -> Maybe t1+checkUndefinedTypeVariablesInTypeScheme path cx ts mkError =++      let freeVars = Variables.freeVariablesInTypeScheme ts+          undefined = Sets.difference freeVars (Graph.graphTypeVariables cx)+      in (Optionals.cases (Lists.maybeHead (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined))+-- | Return an error if the given type is TypeVoid+checkVoid :: Core.Type -> Maybe ErrorCore.InvalidTypeError+checkVoid typ =+    case typ of+      Core.TypeVoid -> Just (ErrorCore.InvalidTypeErrorVoidInNonBottomPosition (ErrorCore.VoidInNonBottomPositionError {+        ErrorCore.voidInNonBottomPositionErrorLocation = (Paths.SubtermPath [])}))+      _ -> Nothing+-- | True iff the given rule name appears in the profile's errorRules or warningRules.+enabled :: Validation.ValidationProfile -> Core.Name -> Bool+enabled p ruleName =+    Logic.or (Sets.member ruleName (Validation.validationProfileErrorRules p)) (Sets.member ruleName (Validation.validationProfileWarningRules p))+-- | Find the first duplicate name in a list+findDuplicate :: Ord t0 => ([t0] -> Maybe t0)+findDuplicate names =++      let result =+              Lists.foldl (\acc -> \name ->+                let seen = Pairs.first acc+                    dup = Pairs.second acc+                in (Optionals.cases dup (Logic.ifElse (Sets.member name seen) (seen, (Just name)) (Sets.insert name seen, Nothing)) (\_ -> acc))) (Sets.empty, Nothing) names+      in (Pairs.second result)+-- | Find the first duplicate name in a list (for field type validation)+findDuplicateFieldType :: Ord t0 => ([t0] -> Maybe t0)+findDuplicateFieldType names =++      let result =+              Lists.foldl (\acc -> \name ->+                let seen = Pairs.first acc+                    dup = Pairs.second acc+                in (Optionals.cases dup (Logic.ifElse (Sets.member name seen) (seen, (Just name)) (Sets.insert name seen, Nothing)) (\_ -> acc))) (Sets.empty, Nothing) names+      in (Pairs.second result)+-- | Return the first error from a list of optional errors, or nothing if all are valid+firstError :: [Maybe t0] -> Maybe t0+firstError checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+-- | Return the first rule-tagged finding from a list, or nothing if all are valid+firstFinding :: [Maybe t0] -> Maybe t0+firstFinding checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+-- | Return the first rule-tagged type finding from a list, or nothing if all are valid+firstFindingType :: [Maybe t0] -> Maybe t0+firstFindingType checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+-- | Return the first type error from a list of optional errors, or nothing if all are valid+firstTypeError :: [Maybe t0] -> Maybe t0+firstTypeError checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+-- | Check whether a name is valid at an introduction site. Currently rejects empty strings.+isValidName :: Core.Name -> Bool+isValidName name = Logic.not (Equality.equal (Core.unName name) "")+-- | The default validation profile for term and type validation, with every check classified as an error except InvalidTypeError.singleVariantUnion (warning); maxErrors=1, maxWarnings=20.+kernelDefaultCoreProfile :: Validation.ValidationProfile+kernelDefaultCoreProfile =+    Validation.ValidationProfile {+      Validation.validationProfileErrorRules = (Sets.fromList [+        Core.Name "hydra.error.core.InvalidTermError.constantCondition",+        (Core.Name "hydra.error.core.InvalidTermError.duplicateBinding"),+        (Core.Name "hydra.error.core.InvalidTermError.duplicateField"),+        (Core.Name "hydra.error.core.InvalidTermError.emptyCaseStatement"),+        (Core.Name "hydra.error.core.InvalidTermError.emptyLetBindings"),+        (Core.Name "hydra.error.core.InvalidTermError.emptyTermAnnotation"),+        (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm"),+        (Core.Name "hydra.error.core.InvalidTermError.invalidLambdaParameterName"),+        (Core.Name "hydra.error.core.InvalidTermError.invalidLetBindingName"),+        (Core.Name "hydra.error.core.InvalidTermError.invalidTypeLambdaParameterName"),+        (Core.Name "hydra.error.core.InvalidTermError.nestedTermAnnotation"),+        (Core.Name "hydra.error.core.InvalidTermError.redundantWrapUnwrap"),+        (Core.Name "hydra.error.core.InvalidTermError.selfApplication"),+        (Core.Name "hydra.error.core.InvalidTermError.termVariableShadowing"),+        (Core.Name "hydra.error.core.InvalidTermError.typeVariableShadowingInTypeLambda"),+        (Core.Name "hydra.error.core.InvalidTermError.undefinedTermVariable"),+        (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInBindingType"),+        (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInLambdaDomain"),+        (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInTypeApplication"),+        (Core.Name "hydra.error.core.InvalidTermError.unknownPrimitiveName"),+        (Core.Name "hydra.error.core.InvalidTermError.unnecessaryIdentityApplication"),+        (Core.Name "hydra.error.core.InvalidTermError.untypedTermVariable"),+        (Core.Name "hydra.error.core.InvalidTypeError.duplicateRecordTypeFieldNames"),+        (Core.Name "hydra.error.core.InvalidTypeError.duplicateUnionTypeFieldNames"),+        (Core.Name "hydra.error.core.InvalidTypeError.emptyRecordType"),+        (Core.Name "hydra.error.core.InvalidTypeError.emptyTypeAnnotation"),+        (Core.Name "hydra.error.core.InvalidTypeError.emptyUnionType"),+        (Core.Name "hydra.error.core.InvalidTypeError.invalidForallParameterName"),+        (Core.Name "hydra.error.core.InvalidTypeError.invalidTypeSchemeVariableName"),+        (Core.Name "hydra.error.core.InvalidTypeError.nestedTypeAnnotation"),+        (Core.Name "hydra.error.core.InvalidTypeError.nonComparableMapKeyType"),+        (Core.Name "hydra.error.core.InvalidTypeError.nonComparableSetElementType"),+        (Core.Name "hydra.error.core.InvalidTypeError.typeVariableShadowingInForall"),+        (Core.Name "hydra.error.core.InvalidTypeError.undefinedTypeVariable"),+        (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")]),+      Validation.validationProfileWarningRules = (Sets.fromList [+        Core.Name "hydra.error.core.InvalidTypeError.singleVariantUnion"]),+      Validation.validationProfileMaxErrors = 1,+      Validation.validationProfileMaxWarnings = 20}+-- | Validate a term against the given ValidationProfile, returning a ValidationResult. Errors hard-stop traversal once maxErrors is reached; warnings are bounded by maxWarnings without causing termination.+term :: Validation.ValidationProfile -> Bool -> Graph.Graph -> Core.Term -> Validation.ValidationResult ErrorCore.InvalidTermError+term p typed g t =+    Rewriting.foldTermWithGraphAndPath (\recurse -> \path -> \cx -> \acc -> \trm -> Logic.ifElse (Equality.gte (Lists.length (Validation.validationResultErrors acc)) (Validation.validationProfileMaxErrors p)) acc (+      let acc1 = appendFinding p acc (checkTerm p typed (Paths.SubtermPath path) cx trm)+      in (Logic.ifElse (Equality.gte (Lists.length (Validation.validationResultErrors acc1)) (Validation.validationProfileMaxErrors p)) acc1 (recurse acc1 trm)))) g (Validation.ValidationResult {+      Validation.validationResultErrors = [],+      Validation.validationResultWarnings = []}) t+-- | Validate a type against the given ValidationProfile, threading a ValidationResult accumulator through subtypes. Errors hard-stop traversal once maxErrors is reached.+type_ :: Validation.ValidationProfile -> Validation.ValidationResult ErrorCore.InvalidTypeError -> S.Set Core.Name -> Core.Type -> Validation.ValidationResult ErrorCore.InvalidTypeError+type_ p acc boundVars typ =+    Logic.ifElse (Equality.gte (Lists.length (Validation.validationResultErrors acc)) (Validation.validationProfileMaxErrors p)) acc (+      let acc1 = appendFindingType p acc (validateTypeNode p boundVars typ)+      in (Logic.ifElse (Equality.gte (Lists.length (Validation.validationResultErrors acc1)) (Validation.validationProfileMaxErrors p)) acc1 (case typ of+        Core.TypeForall v0 ->+          let newBound = Sets.insert (Core.forallTypeParameter v0) boundVars+          in (type_ p acc1 newBound (Core.forallTypeBody v0))+        Core.TypeAnnotated v0 -> type_ p acc1 boundVars (Core.annotatedTypeBody v0)+        Core.TypeApplication v0 ->+          let acc2 = type_ p acc1 boundVars (Core.applicationTypeFunction v0)+          in (type_ p acc2 boundVars (Core.applicationTypeArgument v0))+        Core.TypeEither v0 ->+          let acc2 = type_ p acc1 boundVars (Core.eitherTypeLeft v0)+          in (type_ p acc2 boundVars (Core.eitherTypeRight v0))+        Core.TypeFunction v0 ->+          let acc2 = type_ p acc1 boundVars (Core.functionTypeDomain v0)+          in (type_ p acc2 boundVars (Core.functionTypeCodomain v0))+        Core.TypeList v0 -> type_ p acc1 boundVars v0+        Core.TypeMap v0 ->+          let acc2 = type_ p acc1 boundVars (Core.mapTypeKeys v0)+          in (type_ p acc2 boundVars (Core.mapTypeValues v0))+        Core.TypeOptional v0 -> type_ p acc1 boundVars v0+        Core.TypePair v0 ->+          let acc2 = type_ p acc1 boundVars (Core.pairTypeFirst v0)+          in (type_ p acc2 boundVars (Core.pairTypeSecond v0))+        Core.TypeRecord v0 -> Lists.foldl (\a -> \f -> type_ p a boundVars (Core.fieldTypeType f)) acc1 v0+        Core.TypeSet v0 -> type_ p acc1 boundVars v0+        Core.TypeUnion v0 -> Lists.foldl (\a -> \f -> type_ p a boundVars (Core.fieldTypeType f)) acc1 v0+        Core.TypeWrap v0 -> type_ p acc1 boundVars v0+        _ -> acc1)))+-- | Check a single type node for validation errors. Rules disabled by the profile are not evaluated.+validateTypeNode :: Validation.ValidationProfile -> S.Set Core.Name -> Core.Type -> Maybe (Core.Name, ErrorCore.InvalidTypeError)+validateTypeNode p boundVars typ =+    case typ of+      Core.TypeAnnotated v0 ->+        let body = Core.annotatedTypeBody v0+            annMap = Annotations.getAnnotationMap (Core.annotatedTypeAnnotation v0)+        in (firstFindingType [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.emptyTypeAnnotation")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.emptyTypeAnnotation", f)) (Logic.ifElse (Maps.null annMap) (Just (ErrorCore.InvalidTypeErrorEmptyTypeAnnotation (ErrorCore.EmptyTypeAnnotationError {+            ErrorCore.emptyTypeAnnotationErrorLocation = (Paths.SubtermPath [])}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.nestedTypeAnnotation")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.nestedTypeAnnotation", f)) (case body of+            Core.TypeAnnotated _ -> Just (ErrorCore.InvalidTypeErrorNestedTypeAnnotation (ErrorCore.NestedTypeAnnotationError {+              ErrorCore.nestedTypeAnnotationErrorLocation = (Paths.SubtermPath [])}))+            _ -> Nothing)) Nothing)])+      Core.TypeEither v0 -> firstFindingType [+        Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid (Core.eitherTypeLeft v0))) Nothing,+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid (Core.eitherTypeRight v0))) Nothing)]+      Core.TypeForall v0 ->+        let paramName = Core.forallTypeParameter v0+        in (firstFindingType [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.typeVariableShadowingInForall")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.typeVariableShadowingInForall", f)) (Logic.ifElse (Sets.member paramName boundVars) (Just (ErrorCore.InvalidTypeErrorTypeVariableShadowingInForall (ErrorCore.TypeVariableShadowingInForallError {+            ErrorCore.typeVariableShadowingInForallErrorLocation = (Paths.SubtermPath []),+            ErrorCore.typeVariableShadowingInForallErrorName = paramName}))) Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.invalidForallParameterName")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.invalidForallParameterName", f)) (Logic.ifElse (isValidName paramName) Nothing (Just (ErrorCore.InvalidTypeErrorInvalidForallParameterName (ErrorCore.InvalidForallParameterNameError {+            ErrorCore.invalidForallParameterNameErrorLocation = (Paths.SubtermPath []),+            ErrorCore.invalidForallParameterNameErrorName = paramName}))))) Nothing)])+      Core.TypeFunction v0 -> Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid (Core.functionTypeCodomain v0))) Nothing+      Core.TypeList v0 -> Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid v0)) Nothing+      Core.TypeMap v0 ->+        let keyType = Core.mapTypeKeys v0+        in (firstFindingType [+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.nonComparableMapKeyType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.nonComparableMapKeyType", f)) (case keyType of+            Core.TypeFunction _ -> Just (ErrorCore.InvalidTypeErrorNonComparableMapKeyType (ErrorCore.NonComparableMapKeyTypeError {+              ErrorCore.nonComparableMapKeyTypeErrorLocation = (Paths.SubtermPath []),+              ErrorCore.nonComparableMapKeyTypeErrorKeyType = keyType}))+            _ -> Nothing)) Nothing,+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid keyType)) Nothing),+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid (Core.mapTypeValues v0))) Nothing)])+      Core.TypePair v0 -> firstFindingType [+        Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid (Core.pairTypeFirst v0))) Nothing,+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid (Core.pairTypeSecond v0))) Nothing)]+      Core.TypeRecord v0 -> firstFindingType [+        Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.emptyRecordType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.emptyRecordType", f)) (Logic.ifElse (Lists.null v0) (Just (ErrorCore.InvalidTypeErrorEmptyRecordType (ErrorCore.EmptyRecordTypeError {+          ErrorCore.emptyRecordTypeErrorLocation = (Paths.SubtermPath [])}))) Nothing)) Nothing,+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.duplicateRecordTypeFieldNames")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.duplicateRecordTypeFieldNames", f)) (checkDuplicateFieldTypes v0 (\dupName -> Just (ErrorCore.InvalidTypeErrorDuplicateRecordTypeFieldNames (ErrorCore.DuplicateRecordTypeFieldNamesError {+          ErrorCore.duplicateRecordTypeFieldNamesErrorLocation = (Paths.SubtermPath []),+          ErrorCore.duplicateRecordTypeFieldNamesErrorName = dupName}))))) Nothing),+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (firstTypeError (Lists.map (\f -> checkVoid (Core.fieldTypeType f)) v0))) Nothing)]+      Core.TypeSet v0 -> firstFindingType [+        Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.nonComparableSetElementType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.nonComparableSetElementType", f)) (case v0 of+          Core.TypeFunction _ -> Just (ErrorCore.InvalidTypeErrorNonComparableSetElementType (ErrorCore.NonComparableSetElementTypeError {+            ErrorCore.nonComparableSetElementTypeErrorLocation = (Paths.SubtermPath []),+            ErrorCore.nonComparableSetElementTypeErrorElementType = v0}))+          _ -> Nothing)) Nothing,+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (checkVoid v0)) Nothing)]+      Core.TypeUnion v0 -> firstFindingType [+        Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.emptyUnionType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.emptyUnionType", f)) (Logic.ifElse (Lists.null v0) (Just (ErrorCore.InvalidTypeErrorEmptyUnionType (ErrorCore.EmptyUnionTypeError {+          ErrorCore.emptyUnionTypeErrorLocation = (Paths.SubtermPath [])}))) Nothing)) Nothing,+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.singleVariantUnion")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.singleVariantUnion", f)) (Logic.ifElse (Equality.equal (Lists.length v0) 1) (Optionals.cases (Lists.maybeHead v0) Nothing (\singleField -> Just (ErrorCore.InvalidTypeErrorSingleVariantUnion (ErrorCore.SingleVariantUnionError {+          ErrorCore.singleVariantUnionErrorLocation = (Paths.SubtermPath []),+          ErrorCore.singleVariantUnionErrorFieldName = (Core.fieldTypeName singleField)})))) Nothing)) Nothing),+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.duplicateUnionTypeFieldNames")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.duplicateUnionTypeFieldNames", f)) (checkDuplicateFieldTypes v0 (\dupName -> Just (ErrorCore.InvalidTypeErrorDuplicateUnionTypeFieldNames (ErrorCore.DuplicateUnionTypeFieldNamesError {+          ErrorCore.duplicateUnionTypeFieldNamesErrorLocation = (Paths.SubtermPath []),+          ErrorCore.duplicateUnionTypeFieldNamesErrorName = dupName}))))) Nothing),+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.voidInNonBottomPosition", f)) (firstTypeError (Lists.map (\f -> checkVoid (Core.fieldTypeType f)) v0))) Nothing)]+      Core.TypeVariable v0 -> Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.undefinedTypeVariable")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.undefinedTypeVariable", f)) (Logic.ifElse (Sets.member v0 boundVars) Nothing (Just (ErrorCore.InvalidTypeErrorUndefinedTypeVariable (ErrorCore.UndefinedTypeVariableError {+        ErrorCore.undefinedTypeVariableErrorLocation = (Paths.SubtermPath []),+        ErrorCore.undefinedTypeVariableErrorName = v0}))))) Nothing+      _ -> Nothing
+ src/main/haskell/Hydra/Validate/Packaging.hs view
@@ -0,0 +1,313 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Validation functions for modules and packages++module Hydra.Validate.Packaging where+import qualified Hydra.Annotations as Annotations+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Formatting as Formatting+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+import qualified Hydra.Haskell.Lib.Equality as Equality+import qualified Hydra.Haskell.Lib.Lists as Lists+import qualified Hydra.Haskell.Lib.Logic as Logic+import qualified Hydra.Haskell.Lib.Maps as Maps+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.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | Append a rule-tagged InvalidModuleError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds.+appendFindingModule :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0+appendFindingModule p acc finding =+    Optionals.cases finding acc (\rp ->+      let ruleName = Pairs.first rp+          payload = Pairs.second rp+          errs = Validation.validationResultErrors acc+          wrns = Validation.validationResultWarnings acc+      in (Logic.ifElse (Sets.member ruleName (Validation.validationProfileErrorRules p)) (Logic.ifElse (Equality.lt (Lists.length errs) (Validation.validationProfileMaxErrors p)) (Validation.ValidationResult {+        Validation.validationResultErrors = (Lists.concat2 errs (Lists.singleton payload)),+        Validation.validationResultWarnings = wrns}) acc) (Logic.ifElse (Sets.member ruleName (Validation.validationProfileWarningRules p)) (Logic.ifElse (Equality.lt (Lists.length wrns) (Validation.validationProfileMaxWarnings p)) (Validation.ValidationResult {+        Validation.validationResultErrors = errs,+        Validation.validationResultWarnings = (Lists.concat2 wrns (Lists.singleton payload))}) acc) acc)))+-- | Append a rule-tagged InvalidPackageError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds.+appendFindingPackage :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0+appendFindingPackage p acc finding =+    Optionals.cases finding acc (\rp ->+      let ruleName = Pairs.first rp+          payload = Pairs.second rp+          errs = Validation.validationResultErrors acc+          wrns = Validation.validationResultWarnings acc+      in (Logic.ifElse (Sets.member ruleName (Validation.validationProfileErrorRules p)) (Logic.ifElse (Equality.lt (Lists.length errs) (Validation.validationProfileMaxErrors p)) (Validation.ValidationResult {+        Validation.validationResultErrors = (Lists.concat2 errs (Lists.singleton payload)),+        Validation.validationResultWarnings = wrns}) acc) (Logic.ifElse (Sets.member ruleName (Validation.validationProfileWarningRules p)) (Logic.ifElse (Equality.lt (Lists.length wrns) (Validation.validationProfileMaxWarnings p)) (Validation.ValidationResult {+        Validation.validationResultErrors = errs,+        Validation.validationResultWarnings = (Lists.concat2 wrns (Lists.singleton payload))}) acc) acc)))+-- | Check for module namespaces that conflict when mapped to target language paths+checkConflictingModuleNames :: Packaging.Package -> Maybe ErrorPackaging.InvalidPackageError+checkConflictingModuleNames pkg =++      let result =+              Lists.foldl (\acc -> \mod ->+                let seen = Pairs.first acc+                    err = Pairs.second acc+                in (Optionals.cases err (+                  let ns = Packaging.moduleName mod+                      key = Strings.toLower (Packaging.unModuleName ns)+                      existing = Maps.lookup key seen+                  in (Optionals.cases existing (Maps.insert key ns seen, Nothing) (\first -> (+                    seen,+                    (Just (ErrorPackaging.InvalidPackageErrorConflictingModuleName (ErrorPackaging.ConflictingModuleNameError {+                      ErrorPackaging.conflictingModuleNameErrorFirst = first,+                      ErrorPackaging.conflictingModuleNameErrorSecond = ns}))))))) (\_ -> acc))) (Maps.empty, Nothing) (Packaging.packageModules pkg)+      in (Pairs.second result)+-- | Check for union variant names that, when mapped to constructor names, conflict with other type definitions+checkConflictingVariantNames :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+checkConflictingVariantNames mod =++      let ns = Packaging.moduleName mod+          defs = Packaging.moduleDefinitions mod+          defNames = Lists.foldl (\acc -> \def -> Sets.insert (Names.localNameOf (definitionName def)) acc) Sets.empty defs+      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (case def of+        Packaging.DefinitionType v0 ->+          let typeName = Packaging.typeDefinitionName v0+              localTypeName = Names.localNameOf typeName+              typ = Core.typeSchemeBody (Packaging.typeDefinitionBody v0)+          in case typ of+            Core.TypeUnion v1 -> Lists.foldl (\innerAcc -> \field -> Optionals.cases innerAcc (+              let fieldName = Core.fieldTypeName field+                  localFieldName = Names.localNameOf fieldName+                  constructorName = Strings.cat2 (Formatting.capitalize localTypeName) (Formatting.capitalize localFieldName)+              in (Logic.ifElse (Sets.member constructorName defNames) (Just (ErrorPackaging.InvalidModuleErrorConflictingVariantName (ErrorPackaging.ConflictingVariantNameError {+                ErrorPackaging.conflictingVariantNameErrorModuleName = ns,+                ErrorPackaging.conflictingVariantNameErrorTypeName = typeName,+                ErrorPackaging.conflictingVariantNameErrorVariantName = fieldName,+                ErrorPackaging.conflictingVariantNameErrorConflictingName = (Core.Name constructorName)}))) Nothing)) (\_ -> innerAcc)) Nothing v1+            _ -> Nothing+        _ -> Nothing) (\_ -> acc)) Nothing defs)+-- | Check that every top-level definition is wrapped in a description annotation+checkDefinitionDocumentation :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+checkDefinitionDocumentation mod =++      let ns = Packaging.moduleName mod+      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (+        let name = definitionName def+            documented =+                    case def of+                      Packaging.DefinitionTerm v0 ->+                        let term = Packaging.termDefinitionBody v0+                        in case term of+                          Core.TermAnnotated v1 -> Annotations.hasDescription (Annotations.getAnnotationMap (Core.annotatedTermAnnotation v1))+                          _ -> False+                      Packaging.DefinitionType v0 ->+                        let typ = Core.typeSchemeBody (Packaging.typeDefinitionBody v0)+                        in case typ of+                          Core.TypeAnnotated v1 -> Annotations.hasDescription (Annotations.getAnnotationMap (Core.annotatedTypeAnnotation v1))+                          _ -> False+                      Packaging.DefinitionPrimitive v0 -> Optionals.cases (Packaging.primitiveDefinitionMetadata v0) False (\em -> Logic.not (Equality.equal (Optionals.fromOptional "" (Packaging.entityMetadataDescription em)) ""))+                      _ -> False+        in (Logic.ifElse documented Nothing (Just (ErrorPackaging.InvalidModuleErrorMissingDocumentation (ErrorPackaging.MissingDocumentationError {+          ErrorPackaging.missingDocumentationErrorModuleName = ns,+          ErrorPackaging.missingDocumentationErrorName = name}))))) (\_ -> acc)) Nothing (Packaging.moduleDefinitions mod))+-- | Check that all definition names in a module have the module's name as a prefix+checkDefinitionModuleNames :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+checkDefinitionModuleNames mod =++      let ns = Packaging.moduleName mod+          prefix = Strings.cat2 (Packaging.unModuleName ns) "."+          prefixLen = Strings.length prefix+      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (+        let name = definitionName def+            nameStr = Core.unName name+            namePrefix = Lists.take prefixLen (Strings.toList nameStr)+        in (Logic.ifElse (Equality.equal (Strings.fromList namePrefix) prefix) Nothing (Just (ErrorPackaging.InvalidModuleErrorDefinitionNotInModuleName (ErrorPackaging.DefinitionNotInModuleNameError {+          ErrorPackaging.definitionNotInModuleNameErrorModuleName = ns,+          ErrorPackaging.definitionNotInModuleNameErrorName = name}))))) (\_ -> acc)) Nothing (Packaging.moduleDefinitions mod))+-- | Check that term definitions have camelCase local names and type definitions have PascalCase local names+checkDefinitionNameConvention :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+checkDefinitionNameConvention mod =++      let ns = Packaging.moduleName mod+      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (+        let name = definitionName def+            local = Names.localNameOf name+            expected =+                    case def of+                      Packaging.DefinitionTerm _ -> Util.CaseConventionCamel+                      Packaging.DefinitionType _ -> Util.CaseConventionPascal+                      Packaging.DefinitionPrimitive _ -> Util.CaseConventionCamel+                      _ -> Util.CaseConventionCamel+            pattern =+                    case def of+                      Packaging.DefinitionTerm _ -> Constants.regexCamelCase+                      Packaging.DefinitionType _ -> Constants.regexPascalCase+                      Packaging.DefinitionPrimitive _ -> Constants.regexCamelCase+                      _ -> Constants.regexCamelCase+        in (Logic.ifElse (Regex.matches pattern local) Nothing (Just (ErrorPackaging.InvalidModuleErrorInvalidDefinitionName (ErrorPackaging.InvalidDefinitionNameError {+          ErrorPackaging.invalidDefinitionNameErrorModuleName = ns,+          ErrorPackaging.invalidDefinitionNameErrorName = name,+          ErrorPackaging.invalidDefinitionNameErrorExpectedConvention = expected}))))) (\_ -> acc)) Nothing (Packaging.moduleDefinitions mod))+-- | Check that a module's definitions list is sorted in ascending lexicographic order by local name+checkDefinitionOrdering :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+checkDefinitionOrdering mod =++      let ns = Packaging.moduleName mod+          result =+                  Lists.foldl (\acc -> \def ->+                    let prev = Pairs.first acc+                        err = Pairs.second acc+                    in (Optionals.cases err (+                      let currName = definitionName def+                          currLocal = Names.localNameOf currName+                      in (Optionals.cases prev (Just currName, Nothing) (\prevName ->+                        let prevLocal = Names.localNameOf prevName+                        in (Logic.ifElse (Equality.lt prevLocal currLocal) (Just currName, Nothing) (+                          Just currName,+                          (Just (ErrorPackaging.InvalidModuleErrorDefinitionsOutOfOrder (ErrorPackaging.DefinitionsOutOfOrderError {+                            ErrorPackaging.definitionsOutOfOrderErrorModuleName = ns,+                            ErrorPackaging.definitionsOutOfOrderErrorPrecedingName = prevName,+                            ErrorPackaging.definitionsOutOfOrderErrorFollowingName = currName})))))))) (\_ -> acc))) (Nothing, Nothing) (Packaging.moduleDefinitions mod)+      in (Pairs.second result)+-- | Check for duplicate definition names in a module+checkDuplicateDefinitionNames :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+checkDuplicateDefinitionNames mod =++      let ns = Packaging.moduleName mod+          result =+                  Lists.foldl (\acc -> \def ->+                    let seen = Pairs.first acc+                        err = Pairs.second acc+                    in (Optionals.cases err (+                      let name = definitionName def+                      in (Logic.ifElse (Sets.member name seen) (+                        seen,+                        (Just (ErrorPackaging.InvalidModuleErrorDuplicateDefinitionName (ErrorPackaging.DuplicateDefinitionNameError {+                          ErrorPackaging.duplicateDefinitionNameErrorModuleName = ns,+                          ErrorPackaging.duplicateDefinitionNameErrorName = name})))) (Sets.insert name seen, Nothing))) (\_ -> acc))) (Sets.empty, Nothing) (Packaging.moduleDefinitions mod)+      in (Pairs.second result)+-- | Check for duplicate module namespaces in a package+checkDuplicateModuleNames :: Packaging.Package -> Maybe ErrorPackaging.InvalidPackageError+checkDuplicateModuleNames pkg =++      let result =+              Lists.foldl (\acc -> \mod ->+                let seen = Pairs.first acc+                    err = Pairs.second acc+                in (Optionals.cases err (+                  let ns = Packaging.moduleName mod+                  in (Logic.ifElse (Sets.member ns seen) (+                    seen,+                    (Just (ErrorPackaging.InvalidPackageErrorDuplicateModuleName (ErrorPackaging.DuplicateModuleNameError {+                      ErrorPackaging.duplicateModuleNameErrorModuleName = ns})))) (Sets.insert ns seen, Nothing))) (\_ -> acc))) (Sets.empty, Nothing) (Packaging.packageModules pkg)+      in (Pairs.second result)+-- | Check that the module's namespace matches the dotted-lowercase naming convention+checkModuleNameConvention :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+checkModuleNameConvention mod =++      let ns = Packaging.moduleName mod+      in (Logic.ifElse (Regex.matches Constants.regexNamespace (Packaging.unModuleName ns)) Nothing (Just (ErrorPackaging.InvalidModuleErrorInvalidModuleNameConvention (ErrorPackaging.InvalidModuleNameConventionError {+        ErrorPackaging.invalidModuleNameConventionErrorModuleName = ns}))))+-- | Check that the package's name matches the hyphen-separated lowercase naming convention+checkPackageNameConvention :: Packaging.Package -> Maybe ErrorPackaging.InvalidPackageError+checkPackageNameConvention pkg =++      let pname = Packaging.packageName pkg+      in (Logic.ifElse (Regex.matches Constants.regexPackageName (Packaging.unPackageName pname)) Nothing (Just (ErrorPackaging.InvalidPackageErrorInvalidPackageName (ErrorPackaging.InvalidPackageNameError {+        ErrorPackaging.invalidPackageNameErrorPackageName = pname}))))+-- | Extract the name from a definition+definitionName :: Packaging.Definition -> Core.Name+definitionName def =+    case def of+      Packaging.DefinitionTerm v0 -> Packaging.termDefinitionName v0+      Packaging.DefinitionType v0 -> Packaging.typeDefinitionName v0+      Packaging.DefinitionPrimitive v0 -> Packaging.primitiveDefinitionName v0+-- | True iff the given rule name appears in the profile's errorRules or warningRules.+enabledPackaging :: Validation.ValidationProfile -> Core.Name -> Bool+enabledPackaging p ruleName =+    Logic.or (Sets.member ruleName (Validation.validationProfileErrorRules p)) (Sets.member ruleName (Validation.validationProfileWarningRules p))+-- | The default validation profile for module/package validation. Every kernel-shipped check classified as an error; no warnings; maxErrors=1, maxWarnings=20.+kernelDefaultPackagingProfile :: Validation.ValidationProfile+kernelDefaultPackagingProfile =+    Validation.ValidationProfile {+      Validation.validationProfileErrorRules = (Sets.fromList [+        Core.Name "hydra.error.packaging.InvalidModuleError.conflictingVariantName",+        (Core.Name "hydra.error.packaging.InvalidModuleError.definitionNotInModuleName"),+        (Core.Name "hydra.error.packaging.InvalidModuleError.definitionsOutOfOrder"),+        (Core.Name "hydra.error.packaging.InvalidModuleError.duplicateDefinitionName"),+        (Core.Name "hydra.error.packaging.InvalidModuleError.invalidDefinitionName"),+        (Core.Name "hydra.error.packaging.InvalidModuleError.invalidModuleNameConvention"),+        (Core.Name "hydra.error.packaging.InvalidModuleError.missingDocumentation"),+        (Core.Name "hydra.error.packaging.InvalidPackageError.conflictingModuleName"),+        (Core.Name "hydra.error.packaging.InvalidPackageError.duplicateModuleName"),+        (Core.Name "hydra.error.packaging.InvalidPackageError.invalidPackageName")]),+      Validation.validationProfileWarningRules = Sets.empty,+      Validation.validationProfileMaxErrors = 1,+      Validation.validationProfileMaxWarnings = 20}+-- | Validate a kernel module against all kernel-default packaging rules; returns the first error found or nothing if valid. Convenience wrapper around 'module'' with 'kernelDefaultPackagingProfile'.+kernelModule :: Packaging.Module -> Maybe ErrorPackaging.InvalidModuleError+kernelModule mod =+    Lists.maybeHead (Validation.validationResultErrors (module_ kernelDefaultPackagingProfile (Validation.ValidationResult {+      Validation.validationResultErrors = [],+      Validation.validationResultWarnings = []}) mod))+-- | Validate a kernel package against all kernel-default packaging rules; returns the first error found or nothing if valid. Convenience wrapper around 'package' with 'kernelDefaultPackagingProfile'.+kernelPackage :: Packaging.Package -> Maybe ErrorPackaging.InvalidPackageError+kernelPackage pkg =+    Lists.maybeHead (Validation.validationResultErrors (package kernelDefaultPackagingProfile (Validation.ValidationResult {+      Validation.validationResultErrors = [],+      Validation.validationResultWarnings = []}) pkg))+-- | Validate a module against the given ValidationProfile, accumulating findings into a ValidationResult. Errors hard-stop the rule sequence once maxErrors is reached.+module_ :: Validation.ValidationProfile -> Validation.ValidationResult ErrorPackaging.InvalidModuleError -> Packaging.Module -> Validation.ValidationResult ErrorPackaging.InvalidModuleError+module_ p acc0 mod =+    Lists.foldl (\acc -> \guarded -> Logic.ifElse (Equality.gte (Lists.length (Validation.validationResultErrors acc)) (Validation.validationProfileMaxErrors p)) acc (appendFindingModule p acc guarded)) acc0 [+      Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidModuleError.conflictingVariantName")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidModuleError.conflictingVariantName", f)) (checkConflictingVariantNames mod)) Nothing,+      (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidModuleError.missingDocumentation")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidModuleError.missingDocumentation", f)) (checkDefinitionDocumentation mod)) Nothing),+      (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidModuleError.invalidDefinitionName")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidModuleError.invalidDefinitionName", f)) (checkDefinitionNameConvention mod)) Nothing),+      (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidModuleError.definitionNotInModuleName")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidModuleError.definitionNotInModuleName", f)) (checkDefinitionModuleNames mod)) Nothing),+      (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidModuleError.definitionsOutOfOrder")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidModuleError.definitionsOutOfOrder", f)) (checkDefinitionOrdering mod)) Nothing),+      (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidModuleError.duplicateDefinitionName")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidModuleError.duplicateDefinitionName", f)) (checkDuplicateDefinitionNames mod)) Nothing),+      (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidModuleError.invalidModuleNameConvention")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidModuleError.invalidModuleNameConvention", f)) (checkModuleNameConvention mod)) Nothing)]+-- | Validate a package against the given ValidationProfile, accumulating findings into a ValidationResult. Errors hard-stop traversal once maxErrors is reached.+package :: Validation.ValidationProfile -> Validation.ValidationResult ErrorPackaging.InvalidPackageError -> Packaging.Package -> Validation.ValidationResult ErrorPackaging.InvalidPackageError+package p acc0 pkg =++      let accPkg =+              Lists.foldl (\acc -> \guarded -> Logic.ifElse (Equality.gte (Lists.length (Validation.validationResultErrors acc)) (Validation.validationProfileMaxErrors p)) acc (appendFindingPackage p acc guarded)) acc0 [+                Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidPackageError.conflictingModuleName")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidPackageError.conflictingModuleName", f)) (checkConflictingModuleNames pkg)) Nothing,+                (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidPackageError.duplicateModuleName")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidPackageError.duplicateModuleName", f)) (checkDuplicateModuleNames pkg)) Nothing),+                (Logic.ifElse (enabledPackaging p (Core.Name "hydra.error.packaging.InvalidPackageError.invalidPackageName")) (Optionals.map (\f -> (Core.Name "hydra.error.packaging.InvalidPackageError.invalidPackageName", f)) (checkPackageNameConvention pkg)) Nothing)]+      in (Lists.foldl (\acc -> \mod -> Logic.ifElse (Equality.gte (Lists.length (Validation.validationResultErrors acc)) (Validation.validationProfileMaxErrors p)) acc (+        let mr =+                module_ p (Validation.ValidationResult {+                  Validation.validationResultErrors = [],+                  Validation.validationResultWarnings = []}) mod+            liftedErrs = Lists.map (\e -> ErrorPackaging.InvalidPackageErrorInvalidModule e) (Validation.validationResultErrors mr)+            liftedWrns = Lists.map (\w -> ErrorPackaging.InvalidPackageErrorInvalidModule w) (Validation.validationResultWarnings mr)+            newErrs =+                    Lists.take (Validation.validationProfileMaxErrors p) (Lists.concat2 (Validation.validationResultErrors acc) liftedErrs)+            newWrns =+                    Lists.take (Validation.validationProfileMaxWarnings p) (Lists.concat2 (Validation.validationResultWarnings acc) liftedWrns)+        in Validation.ValidationResult {+          Validation.validationResultErrors = newErrs,+          Validation.validationResultWarnings = newWrns})) accPkg (Packaging.packageModules pkg))
+ src/main/haskell/Hydra/Validation.hs view
@@ -0,0 +1,37 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Framework types for configurable validation: profiles classify checks as errors or warnings, and results accumulate findings up to caller-specified bounds.++module Hydra.Validation where+import qualified Hydra.Core as Core+import qualified Hydra.Error.Core as ErrorCore+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Set as S+-- | Configuration for a validation pass: which check rules are active, how each is classified, and the upper bounds on collected findings. A check whose rule name appears in neither set is never evaluated. Errors hard-stop the traversal once maxErrors is reached; warnings only stop being collected once maxWarnings is reached, never causing termination.+data ValidationProfile =+  ValidationProfile {+    -- | The set of fully qualified rule names whose findings are treated as errors. Each name has the form 'hydra.error.<package>.<UnionType>.<variant>', e.g. 'hydra.error.core.InvalidTermError.duplicateBinding'.+    validationProfileErrorRules :: (S.Set Core.Name),+    -- | The set of fully qualified rule names whose findings are treated as warnings. Same name format as errorRules.+    validationProfileWarningRules :: (S.Set Core.Name),+    -- | Hard upper bound on collected errors. Validation terminates as soon as the errors list reaches this length. A value of 1 reproduces the legacy 'first error wins' behaviour.+    validationProfileMaxErrors :: Int,+    -- | Soft upper bound on collected warnings. Once the warnings list reaches this length, further warning matches are silently dropped, but validation does not terminate; it continues until maxErrors is reached or the traversal completes.+    validationProfileMaxWarnings :: Int}+  deriving (Eq, Ord, Read, Show)+_ValidationProfile = Core.Name "hydra.validation.ValidationProfile"+_ValidationProfile_errorRules = Core.Name "errorRules"+_ValidationProfile_warningRules = Core.Name "warningRules"+_ValidationProfile_maxErrors = Core.Name "maxErrors"+_ValidationProfile_maxWarnings = Core.Name "maxWarnings"+-- | The outcome of a validation pass: an ordered list of error findings and an ordered list of warning findings, each parameterized by the finding payload type. The pass is considered successful when 'errors' is empty; warnings are informational and do not affect that judgement.+data ValidationResult e =+  ValidationResult {+    -- | Findings classified as errors, in traversal order, bounded by the profile's maxErrors.+    validationResultErrors :: [e],+    -- | Findings classified as warnings, in traversal order, bounded by the profile's maxWarnings.+    validationResultWarnings :: [e]}+  deriving (Eq, Ord, Read, Show)+_ValidationResult = Core.Name "hydra.validation.ValidationResult"+_ValidationResult_errors = Core.Name "errors"+_ValidationResult_warnings = Core.Name "warnings"
+ src/main/haskell/Hydra/Variables.hs view
@@ -0,0 +1,295 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Free variable analysis, term-level substitution, and unshadowing++module Hydra.Variables where+import qualified Hydra.Ast as Ast+import qualified Hydra.Coders as Coders+import qualified Hydra.Core as Core+import qualified Hydra.Error.Checking as Checking+import qualified Hydra.Error.Core as ErrorCore+import qualified Hydra.Error.Packaging as ErrorPackaging+import qualified Hydra.Errors as Errors+import qualified Hydra.Graph as Graph+import qualified Hydra.Json.Model as Model+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.Sets as Sets+import qualified Hydra.Haskell.Lib.Strings as Strings+import qualified Hydra.Names as Names+import qualified Hydra.Packaging as Packaging+import qualified Hydra.Parsing as Parsing+import qualified Hydra.Paths as Paths+import qualified Hydra.Query as Query+import qualified Hydra.Relational as Relational+import qualified Hydra.Rewriting as Rewriting+import qualified Hydra.Tabular as Tabular+import qualified Hydra.Testing as Testing+import qualified Hydra.Topology as Topology+import qualified Hydra.Typed as Typed+import qualified Hydra.Typing as Typing+import qualified Hydra.Util as Util+import qualified Hydra.Validation as Validation+import qualified Hydra.Variants as Variants+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+import qualified Data.Set as S+-- | Get the set of free type variables in a term (including schema names, where they appear in type annotations). In this context, only the type schemes of let bindings can bind type variables; type lambdas do not.+freeTypeVariablesInTerm :: Core.Term -> S.Set Core.Name+freeTypeVariablesInTerm term0 =++      let allOf = \sets -> Lists.foldl Sets.union Sets.empty sets+          tryType = \tvars -> \typ -> Sets.difference (freeVariablesInType typ) tvars+          getAll =+                  \vars -> \term ->+                    let recurse = getAll vars+                        dflt = allOf (Lists.map recurse (Rewriting.subterms term))+                    in case term of+                      Core.TermLambda v0 ->+                        let domt = Optionals.cases (Core.lambdaDomain v0) Sets.empty (tryType vars)+                        in (Sets.union domt (recurse (Core.lambdaBody v0)))+                      Core.TermLet v0 ->+                        let forBinding =+                                \b ->+                                  let newVars =+                                          Optionals.cases (Core.bindingTypeScheme b) vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts)))+                                  in (Sets.union (getAll newVars (Core.bindingTerm b)) (Optionals.cases (Core.bindingTypeScheme b) Sets.empty (\ts -> tryType newVars (Core.typeSchemeBody ts))))+                        in (Sets.union (allOf (Lists.map forBinding (Core.letBindings v0))) (recurse (Core.letBody v0)))+                      Core.TermTypeApplication v0 -> Sets.union (tryType vars (Core.typeApplicationTermType v0)) (recurse (Core.typeApplicationTermBody v0))+                      Core.TermTypeLambda v0 -> Sets.union (tryType vars (Core.TypeVariable (Core.typeLambdaParameter v0))) (recurse (Core.typeLambdaBody v0))+                      _ -> dflt+      in (getAll Sets.empty term0)+-- | Find the free variables (i.e. variables not bound by a lambda or let) in a term+freeVariablesInTerm :: Core.Term -> S.Set Core.Name+freeVariablesInTerm term =++      let dfltVars = \_ -> Lists.foldl (\s -> \t -> Sets.union s (freeVariablesInTerm t)) Sets.empty (Rewriting.subterms term)+      in case term of+        Core.TermLambda v0 -> Sets.delete (Core.lambdaParameter v0) (freeVariablesInTerm (Core.lambdaBody v0))+        Core.TermLet v0 -> Sets.difference (dfltVars ()) (Sets.fromList (Lists.map Core.bindingName (Core.letBindings v0)))+        Core.TermVariable v0 -> Sets.singleton v0+        _ -> dfltVars ()+-- | Find the free variables (i.e. variables not bound by a lambda or let) in a type+freeVariablesInType :: Core.Type -> S.Set Core.Name+freeVariablesInType typ =++      let dfltVars = Lists.foldl (\s -> \t -> Sets.union s (freeVariablesInType t)) Sets.empty (Rewriting.subtypes typ)+      in case typ of+        Core.TypeForall v0 -> Sets.delete (Core.forallTypeParameter v0) (freeVariablesInType (Core.forallTypeBody v0))+        Core.TypeVariable v0 -> Sets.singleton v0+        _ -> dfltVars+-- | Find the free variables in a type in deterministic left-to-right order+freeVariablesInTypeOrdered :: Core.Type -> [Core.Name]+freeVariablesInTypeOrdered typ =++      let collectVars =+              \boundVars -> \t -> case t of+                Core.TypeVariable v0 -> Logic.ifElse (Sets.member v0 boundVars) [] [+                  v0]+                Core.TypeForall v0 -> collectVars (Sets.insert (Core.forallTypeParameter v0) boundVars) (Core.forallTypeBody v0)+                _ -> Lists.concat (Lists.map (collectVars boundVars) (Rewriting.subtypes t))+      in (Lists.nub (collectVars Sets.empty typ))+-- | Find free variables in a type scheme+freeVariablesInTypeScheme :: Core.TypeScheme -> S.Set Core.Name+freeVariablesInTypeScheme ts =++      let vars = Core.typeSchemeVariables ts+          t = Core.typeSchemeBody ts+      in (Sets.difference (freeVariablesInType t) (Sets.fromList vars))+-- | Find free variables in a type scheme (simple version)+freeVariablesInTypeSchemeSimple :: Core.TypeScheme -> S.Set Core.Name+freeVariablesInTypeSchemeSimple ts =++      let vars = Core.typeSchemeVariables ts+          t = Core.typeSchemeBody ts+      in (Sets.difference (freeVariablesInTypeSimple t) (Sets.fromList vars))+-- | Same as freeVariablesInType, but ignores the binding action of lambda types+freeVariablesInTypeSimple :: Core.Type -> S.Set Core.Name+freeVariablesInTypeSimple typ =++      let helper =+              \types -> \typ2 -> case typ2 of+                Core.TypeVariable v0 -> Sets.insert v0 types+                _ -> types+      in (Rewriting.foldOverType Coders.TraversalOrderPre helper Sets.empty typ)+-- | Check whether a variable is free (not bound) in a term+isFreeVariableInTerm :: Core.Name -> Core.Term -> Bool+isFreeVariableInTerm v term = Logic.not (Sets.member v (freeVariablesInTerm term))+-- | Recursively replace the type variables of let bindings with the systematic type variables t0, t1, t2, ...+normalizeTypeVariablesInTerm :: Core.Term -> Core.Term+normalizeTypeVariablesInTerm term =++      let replaceName = \subst -> \v -> Optionals.fromOptional v (Maps.lookup v subst)+          substType =+                  \subst -> \typ ->+                    let rewrite =+                            \recurse -> \typ2 -> case typ2 of+                              Core.TypeVariable v0 -> Core.TypeVariable (replaceName subst v0)+                              _ -> recurse typ2+                    in (Rewriting.rewriteType rewrite typ)+          rewriteWithSubst =+                  \state -> \term0 ->+                    let sb = Pairs.first state+                        next = Pairs.second state+                        subst = Pairs.first sb+                        boundVars = Pairs.second sb+                        rewrite =+                                \recurse -> \term2 -> case term2 of+                                  Core.TermLambda v0 ->+                                    let domain = Core.lambdaDomain v0+                                    in (Core.TermLambda (Core.Lambda {+                                      Core.lambdaParameter = (Core.lambdaParameter v0),+                                      Core.lambdaDomain = (Optionals.map (substType subst) domain),+                                      Core.lambdaBody = (rewriteWithSubst ((subst, boundVars), next) (Core.lambdaBody v0))}))+                                  Core.TermLet v0 ->+                                    let bindings0 = Core.letBindings v0+                                        body0 = Core.letBody v0+                                        step =+                                                \acc -> \bs -> Optionals.cases (Lists.uncons bs) (Lists.reverse acc) (\uc ->+                                                  let b = Pairs.first uc+                                                      tl = Pairs.second uc+                                                      noType =++                                                                let newVal = rewriteWithSubst ((subst, boundVars), next) (Core.bindingTerm b)+                                                                    b1 =+                                                                            Core.Binding {+                                                                              Core.bindingName = (Core.bindingName b),+                                                                              Core.bindingTerm = newVal,+                                                                              Core.bindingTypeScheme = Nothing}+                                                                in (step (Lists.cons b1 acc) tl)+                                                      withType =+                                                              \ts ->+                                                                let vars = Core.typeSchemeVariables ts+                                                                    typ = Core.typeSchemeBody ts+                                                                    k = Lists.length vars+                                                                    gen =+                                                                            \i -> \rem -> \acc2 ->+                                                                              let ti = Core.Name (Strings.cat2 "t" (Literals.showInt32 (Math.add next i)))+                                                                              in (Logic.ifElse (Equality.equal rem 0) (Lists.reverse acc2) (gen (Math.add i 1) (Math.sub rem 1) (Lists.cons ti acc2)))+                                                                    newVars = gen 0 k []+                                                                    newSubst = Maps.union (Maps.fromList (Lists.zip vars newVars)) subst+                                                                    newBound = Sets.union boundVars (Sets.fromList newVars)+                                                                    newVal = rewriteWithSubst ((newSubst, newBound), (Math.add next k)) (Core.bindingTerm b)+                                                                    renameConstraintKeys =+                                                                            \constraintMap -> Maps.fromList (Lists.map (\p ->+                                                                              let oldName = Pairs.first p+                                                                                  meta = Pairs.second p+                                                                                  newName = Optionals.fromOptional oldName (Maps.lookup oldName newSubst)+                                                                              in (newName, meta)) (Maps.toList constraintMap))+                                                                    oldConstraints = Core.typeSchemeConstraints ts+                                                                    newConstraints = Optionals.map renameConstraintKeys oldConstraints+                                                                    b1 =+                                                                            Core.Binding {+                                                                              Core.bindingName = (Core.bindingName b),+                                                                              Core.bindingTerm = newVal,+                                                                              Core.bindingTypeScheme = (Just (Core.TypeScheme {+                                                                                Core.typeSchemeVariables = newVars,+                                                                                Core.typeSchemeBody = (substType newSubst typ),+                                                                                Core.typeSchemeConstraints = newConstraints}))}+                                                                in (step (Lists.cons b1 acc) tl)+                                                  in (Optionals.cases (Core.bindingTypeScheme b) noType (\ts -> withType ts)))+                                        bindings1 = step [] bindings0+                                    in (Core.TermLet (Core.Let {+                                      Core.letBindings = bindings1,+                                      Core.letBody = (rewriteWithSubst ((subst, boundVars), next) body0)}))+                                  Core.TermTypeApplication v0 -> Core.TermTypeApplication (Core.TypeApplicationTerm {+                                    Core.typeApplicationTermBody = (rewriteWithSubst ((subst, boundVars), next) (Core.typeApplicationTermBody v0)),+                                    Core.typeApplicationTermType = (substType subst (Core.typeApplicationTermType v0))})+                                  Core.TermTypeLambda v0 -> Core.TermTypeLambda (Core.TypeLambda {+                                    Core.typeLambdaParameter = (replaceName subst (Core.typeLambdaParameter v0)),+                                    Core.typeLambdaBody = (rewriteWithSubst ((subst, boundVars), next) (Core.typeLambdaBody v0))})+                                  _ -> recurse term2+                    in (Rewriting.rewriteTerm rewrite term0)+      in (rewriteWithSubst ((Maps.empty, Sets.empty), 0) term)+-- | Replace a free variable in a term+replaceFreeTermVariable :: Core.Name -> Core.Term -> Core.Term -> Core.Term+replaceFreeTermVariable vold tnew term =++      let rewrite =+              \recurse -> \t -> case t of+                Core.TermLambda v0 ->+                  let v = Core.lambdaParameter v0+                  in (Logic.ifElse (Equality.equal v vold) t (recurse t))+                Core.TermVariable v0 -> Logic.ifElse (Equality.equal v0 vold) tnew (Core.TermVariable v0)+                _ -> recurse t+      in (Rewriting.rewriteTerm rewrite term)+-- | Replace free occurrences of a name in a type+replaceFreeTypeVariable :: Core.Name -> Core.Type -> Core.Type -> Core.Type+replaceFreeTypeVariable v rep typ =++      let mapExpr =+              \recurse -> \t -> case t of+                Core.TypeForall v0 -> Logic.ifElse (Equality.equal v (Core.forallTypeParameter v0)) t (Core.TypeForall (Core.ForallType {+                  Core.forallTypeParameter = (Core.forallTypeParameter v0),+                  Core.forallTypeBody = (recurse (Core.forallTypeBody v0))}))+                Core.TypeVariable v0 -> Logic.ifElse (Equality.equal v v0) rep t+                _ -> recurse t+      in (Rewriting.rewriteType mapExpr typ)+-- | Substitute type variables in a type+substituteTypeVariables :: M.Map Core.Name Core.Name -> Core.Type -> Core.Type+substituteTypeVariables subst typ =++      let replace =+              \recurse -> \typ2 -> case typ2 of+                Core.TypeVariable v0 -> Core.TypeVariable (Optionals.fromOptional v0 (Maps.lookup v0 subst))+                _ -> recurse typ2+      in (Rewriting.rewriteType replace typ)+-- | Substitute one variable for another in a term+substituteVariable :: Core.Name -> Core.Name -> Core.Term -> Core.Term+substituteVariable from to term =++      let replace =+              \recurse -> \term2 -> case term2 of+                Core.TermVariable v0 -> Core.TermVariable (Logic.ifElse (Equality.equal v0 from) to v0)+                Core.TermLambda v0 -> Logic.ifElse (Equality.equal (Core.lambdaParameter v0) from) term2 (recurse term2)+                _ -> recurse term2+      in (Rewriting.rewriteTerm replace term)+-- | Substitute multiple variables in a term+substituteVariables :: M.Map Core.Name Core.Name -> Core.Term -> Core.Term+substituteVariables subst term =++      let replace =+              \recurse -> \term2 -> case term2 of+                Core.TermVariable v0 -> Core.TermVariable (Optionals.fromOptional v0 (Maps.lookup v0 subst))+                Core.TermLambda v0 -> Optionals.cases (Maps.lookup (Core.lambdaParameter v0) subst) (recurse term2) (\_ -> term2)+                _ -> recurse term2+      in (Rewriting.rewriteTerm replace term)+-- | Rename all shadowed variables (both lambda parameters and let-bound variables that shadow lambda parameters) in a term.+unshadowVariables :: Core.Term -> Core.Term+unshadowVariables term0 =++      let freshName =+              \base -> \i -> \m ->+                let candidate = Core.Name (Strings.cat2 (Core.unName base) (Literals.showInt32 i))+                in (Logic.ifElse (Maps.member candidate m) (freshName base (Math.add i 1) m) candidate)+          f =+                  \recurse -> \m -> \term -> case term of+                    Core.TermLambda v0 ->+                      let v = Core.lambdaParameter v0+                          domain = Core.lambdaDomain v0+                          body = Core.lambdaBody v0+                      in (Logic.ifElse (Maps.member v m) (+                        let v2 = freshName v 2 m+                            m2 = Maps.insert v v2 (Maps.insert v2 v2 m)+                        in (Core.TermLambda (Core.Lambda {+                          Core.lambdaParameter = v2,+                          Core.lambdaDomain = domain,+                          Core.lambdaBody = (f recurse m2 body)}))) (Core.TermLambda (Core.Lambda {+                        Core.lambdaParameter = v,+                        Core.lambdaDomain = domain,+                        Core.lambdaBody = (f recurse (Maps.insert v v m) body)})))+                    Core.TermLet v0 ->+                      let m2 =+                              Lists.foldl (\acc -> \b ->+                                let bname = Core.bindingName b+                                in (Logic.ifElse (Maps.member bname acc) acc (Maps.insert bname bname acc))) m (Core.letBindings v0)+                      in (recurse m2 term)+                    Core.TermVariable v0 -> Core.TermVariable (Optionals.cases (Maps.lookup v0 m) v0 (\renamed -> renamed))+                    _ -> recurse m term+      in (Rewriting.rewriteTermWithContext f Maps.empty term0)
+ src/main/haskell/Hydra/Variants.hs view
@@ -0,0 +1,107 @@+-- Note: this is an automatically generated file. Do not edit.+-- | Variant types which describe the structure of Hydra core types and terms.++module Hydra.Variants where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+-- | The identifier of a literal constructor+data LiteralVariant =+  LiteralVariantBinary |+  LiteralVariantBoolean |+  LiteralVariantDecimal |+  LiteralVariantFloat |+  LiteralVariantInteger |+  LiteralVariantString+  deriving (Eq, Ord, Read, Show)+_LiteralVariant = Core.Name "hydra.variants.LiteralVariant"+_LiteralVariant_binary = Core.Name "binary"+_LiteralVariant_boolean = Core.Name "boolean"+_LiteralVariant_decimal = Core.Name "decimal"+_LiteralVariant_float = Core.Name "float"+_LiteralVariant_integer = Core.Name "integer"+_LiteralVariant_string = Core.Name "string"+-- | The identifier of a term expression constructor+data TermVariant =+  TermVariantAnnotated |+  TermVariantApplication |+  TermVariantCases |+  TermVariantEither |+  TermVariantInject |+  TermVariantLambda |+  TermVariantLet |+  TermVariantList |+  TermVariantLiteral |+  TermVariantMap |+  TermVariantOptional |+  TermVariantPair |+  TermVariantProject |+  TermVariantRecord |+  TermVariantSet |+  TermVariantTypeApplication |+  TermVariantTypeLambda |+  TermVariantUnit |+  TermVariantUnwrap |+  TermVariantVariable |+  TermVariantWrap+  deriving (Eq, Ord, Read, Show)+_TermVariant = Core.Name "hydra.variants.TermVariant"+_TermVariant_annotated = Core.Name "annotated"+_TermVariant_application = Core.Name "application"+_TermVariant_cases = Core.Name "cases"+_TermVariant_either = Core.Name "either"+_TermVariant_inject = Core.Name "inject"+_TermVariant_lambda = Core.Name "lambda"+_TermVariant_let = Core.Name "let"+_TermVariant_list = Core.Name "list"+_TermVariant_literal = Core.Name "literal"+_TermVariant_map = Core.Name "map"+_TermVariant_optional = Core.Name "optional"+_TermVariant_pair = Core.Name "pair"+_TermVariant_project = Core.Name "project"+_TermVariant_record = Core.Name "record"+_TermVariant_set = Core.Name "set"+_TermVariant_typeApplication = Core.Name "typeApplication"+_TermVariant_typeLambda = Core.Name "typeLambda"+_TermVariant_unit = Core.Name "unit"+_TermVariant_unwrap = Core.Name "unwrap"+_TermVariant_variable = Core.Name "variable"+_TermVariant_wrap = Core.Name "wrap"+-- | The identifier of a type constructor+data TypeVariant =+  TypeVariantAnnotated |+  TypeVariantApplication |+  TypeVariantEither |+  TypeVariantForall |+  TypeVariantFunction |+  TypeVariantList |+  TypeVariantLiteral |+  TypeVariantMap |+  TypeVariantOptional |+  TypeVariantPair |+  TypeVariantRecord |+  TypeVariantSet |+  TypeVariantUnion |+  TypeVariantUnit |+  TypeVariantVariable |+  TypeVariantVoid |+  TypeVariantWrap+  deriving (Eq, Ord, Read, Show)+_TypeVariant = Core.Name "hydra.variants.TypeVariant"+_TypeVariant_annotated = Core.Name "annotated"+_TypeVariant_application = Core.Name "application"+_TypeVariant_either = Core.Name "either"+_TypeVariant_forall = Core.Name "forall"+_TypeVariant_function = Core.Name "function"+_TypeVariant_list = Core.Name "list"+_TypeVariant_literal = Core.Name "literal"+_TypeVariant_map = Core.Name "map"+_TypeVariant_optional = Core.Name "optional"+_TypeVariant_pair = Core.Name "pair"+_TypeVariant_record = Core.Name "record"+_TypeVariant_set = Core.Name "set"+_TypeVariant_union = Core.Name "union"+_TypeVariant_unit = Core.Name "unit"+_TypeVariant_variable = Core.Name "variable"+_TypeVariant_void = Core.Name "void"+_TypeVariant_wrap = Core.Name "wrap"
+ src/main/haskell/Hydra/Yaml/Model.hs view
@@ -0,0 +1,47 @@+-- Note: this is an automatically generated file. Do not edit.+-- | A basic YAML representation model. Based on:+-- |   https://yaml.org/spec/1.2/spec.html+-- | The Serialization and Presentation properties of YAML,+-- | including directives, comments, anchors, style, formatting, and aliases, are not supported by this model.+-- | In addition, tags are omitted from this model, and non-standard scalars are unsupported.++module Hydra.Yaml.Model where+import qualified Hydra.Core as Core+import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)+import qualified Data.Scientific as Sci+import qualified Data.Map as M+-- | A YAML node (value)+data Node =+  -- | A mapping from nodes to nodes+  NodeMapping (M.Map Node Node) |+  -- | A scalar value+  NodeScalar Scalar |+  -- | A sequence of nodes+  NodeSequence [Node]+  deriving (Eq, Ord, Read, Show)+_Node = Core.Name "hydra.yaml.model.Node"+_Node_mapping = Core.Name "mapping"+_Node_scalar = Core.Name "scalar"+_Node_sequence = Core.Name "sequence"+-- | A union of scalars supported in the YAML failsafe and JSON schemas. Other scalars are not supported here+data Scalar =+  -- | Represents a true/false value+  ScalarBool Bool |+  -- | An arbitrary-precision decimal number (lexically a valid JSON number)+  ScalarDecimal Sci.Scientific |+  -- | Represents an approximation to real numbers+  ScalarFloat Double |+  -- | Represents arbitrary sized finite mathematical integers+  ScalarInt Integer |+  -- | Represents the lack of a value+  ScalarNull |+  -- | A string value+  ScalarStr String+  deriving (Eq, Ord, Read, Show)+_Scalar = Core.Name "hydra.yaml.model.Scalar"+_Scalar_bool = Core.Name "bool"+_Scalar_decimal = Core.Name "decimal"+_Scalar_float = Core.Name "float"+_Scalar_int = Core.Name "int"+_Scalar_null = Core.Name "null"+_Scalar_str = Core.Name "str"