diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 --- /dev/null +++ b/CHANGELOG.md @@ -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.` 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` ([#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` instead of `map` ([#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. diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -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. diff --git a/hydra-kernel.cabal b/hydra-kernel.cabal new file mode 100644 --- /dev/null +++ b/hydra-kernel.cabal @@ -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 +maintainer: Joshua Shinavier +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 diff --git a/src/main/haskell/Hydra/Adapt.hs b/src/main/haskell/Hydra/Adapt.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Adapt.hs @@ -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] + _ -> [] diff --git a/src/main/haskell/Hydra/Analysis.hs b/src/main/haskell/Hydra/Analysis.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Analysis.hs @@ -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)))} diff --git a/src/main/haskell/Hydra/Annotations.hs b/src/main/haskell/Hydra/Annotations.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Annotations.hs @@ -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 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 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))) diff --git a/src/main/haskell/Hydra/Arity.hs b/src/main/haskell/Hydra/Arity.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Arity.hs @@ -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] diff --git a/src/main/haskell/Hydra/Ast.hs b/src/main/haskell/Hydra/Ast.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Ast.hs @@ -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" diff --git a/src/main/haskell/Hydra/Checking.hs b/src/main/haskell/Hydra/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Checking.hs @@ -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)])) diff --git a/src/main/haskell/Hydra/Classes.hs b/src/main/haskell/Hydra/Classes.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Classes.hs @@ -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)."} diff --git a/src/main/haskell/Hydra/Codegen.hs b/src/main/haskell/Hydra/Codegen.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Codegen.hs @@ -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) diff --git a/src/main/haskell/Hydra/Coders.hs b/src/main/haskell/Hydra/Coders.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Coders.hs @@ -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" diff --git a/src/main/haskell/Hydra/Constants.hs b/src/main/haskell/Hydra/Constants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Constants.hs @@ -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." diff --git a/src/main/haskell/Hydra/Core.hs b/src/main/haskell/Hydra/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Core.hs @@ -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" diff --git a/src/main/haskell/Hydra/Decode/Ast.hs b/src/main/haskell/Hydra/Decode/Ast.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Ast.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Coders.hs b/src/main/haskell/Hydra/Decode/Coders.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Coders.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Core.hs b/src/main/haskell/Hydra/Decode/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Core.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Error/Checking.hs b/src/main/haskell/Hydra/Decode/Error/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Error/Checking.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Error/Core.hs b/src/main/haskell/Hydra/Decode/Error/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Error/Core.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Errors.hs b/src/main/haskell/Hydra/Decode/Errors.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Errors.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Json/Model.hs b/src/main/haskell/Hydra/Decode/Json/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Json/Model.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Packaging.hs b/src/main/haskell/Hydra/Decode/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Packaging.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Parsing.hs b/src/main/haskell/Hydra/Decode/Parsing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Parsing.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Paths.hs b/src/main/haskell/Hydra/Decode/Paths.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Paths.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Query.hs b/src/main/haskell/Hydra/Decode/Query.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Query.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Relational.hs b/src/main/haskell/Hydra/Decode/Relational.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Relational.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Tabular.hs b/src/main/haskell/Hydra/Decode/Tabular.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Tabular.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Testing.hs b/src/main/haskell/Hydra/Decode/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Testing.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Topology.hs b/src/main/haskell/Hydra/Decode/Topology.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Topology.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Typed.hs b/src/main/haskell/Hydra/Decode/Typed.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Typed.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Typing.hs b/src/main/haskell/Hydra/Decode/Typing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Typing.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Util.hs b/src/main/haskell/Hydra/Decode/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Util.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decode/Variants.hs b/src/main/haskell/Hydra/Decode/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decode/Variants.hs @@ -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) diff --git a/src/main/haskell/Hydra/Decoding.hs b/src/main/haskell/Hydra/Decoding.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Decoding.hs @@ -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 diff --git a/src/main/haskell/Hydra/Dependencies.hs b/src/main/haskell/Hydra/Dependencies.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dependencies.hs @@ -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) diff --git a/src/main/haskell/Hydra/Differentiation.hs b/src/main/haskell/Hydra/Differentiation.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Differentiation.hs @@ -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))))))))))))))))))))) diff --git a/src/main/haskell/Hydra/Dsl/Ast.hs b/src/main/haskell/Hydra/Dsl/Ast.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Ast.hs @@ -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}})) diff --git a/src/main/haskell/Hydra/Dsl/Coders.hs b/src/main/haskell/Hydra/Dsl/Coders.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Coders.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Core.hs b/src/main/haskell/Hydra/Dsl/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Core.hs @@ -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)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Error/Checking.hs b/src/main/haskell/Hydra/Dsl/Error/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Error/Checking.hs @@ -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)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Error/Core.hs b/src/main/haskell/Hydra/Dsl/Error/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Error/Core.hs @@ -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)}]})) diff --git a/src/main/haskell/Hydra/Dsl/Error/Packaging.hs b/src/main/haskell/Hydra/Dsl/Error/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Error/Packaging.hs @@ -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)}]})) diff --git a/src/main/haskell/Hydra/Dsl/Errors.hs b/src/main/haskell/Hydra/Dsl/Errors.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Errors.hs @@ -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)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Graph.hs b/src/main/haskell/Hydra/Dsl/Graph.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Graph.hs @@ -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)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Json/Model.hs b/src/main/haskell/Hydra/Dsl/Json/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Json/Model.hs @@ -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)}})) diff --git a/src/main/haskell/Hydra/Dsl/Literals.hs b/src/main/haskell/Hydra/Dsl/Literals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Literals.hs @@ -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 diff --git a/src/main/haskell/Hydra/Dsl/Meta/Common.hs b/src/main/haskell/Hydra/Dsl/Meta/Common.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Meta/Common.hs @@ -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 diff --git a/src/main/haskell/Hydra/Dsl/Packaging.hs b/src/main/haskell/Hydra/Dsl/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Packaging.hs @@ -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}})) diff --git a/src/main/haskell/Hydra/Dsl/Parsing.hs b/src/main/haskell/Hydra/Dsl/Parsing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Parsing.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Paths.hs b/src/main/haskell/Hydra/Dsl/Paths.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Paths.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Query.hs b/src/main/haskell/Hydra/Dsl/Query.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Query.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Relational.hs b/src/main/haskell/Hydra/Dsl/Relational.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Relational.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Tabular.hs b/src/main/haskell/Hydra/Dsl/Tabular.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Tabular.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Terms.hs b/src/main/haskell/Hydra/Dsl/Terms.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Terms.hs @@ -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). +-- 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 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 diff --git a/src/main/haskell/Hydra/Dsl/Testing.hs b/src/main/haskell/Hydra/Dsl/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Testing.hs @@ -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)}]})) diff --git a/src/main/haskell/Hydra/Dsl/Topology.hs b/src/main/haskell/Hydra/Dsl/Topology.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Topology.hs @@ -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)}))}]})) diff --git a/src/main/haskell/Hydra/Dsl/Typing.hs b/src/main/haskell/Hydra/Dsl/Typing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Typing.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Util.hs b/src/main/haskell/Hydra/Dsl/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Util.hs @@ -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)})) diff --git a/src/main/haskell/Hydra/Dsl/Validation.hs b/src/main/haskell/Hydra/Dsl/Validation.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Validation.hs @@ -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)}]})) diff --git a/src/main/haskell/Hydra/Dsl/Variants.hs b/src/main/haskell/Hydra/Dsl/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Variants.hs @@ -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}})) diff --git a/src/main/haskell/Hydra/Dsl/Yaml/Model.hs b/src/main/haskell/Hydra/Dsl/Yaml/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsl/Yaml/Model.hs @@ -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)}})) diff --git a/src/main/haskell/Hydra/Dsls.hs b/src/main/haskell/Hydra/Dsls.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Dsls.hs @@ -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) diff --git a/src/main/haskell/Hydra/Encode/Ast.hs b/src/main/haskell/Hydra/Encode/Ast.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Ast.hs @@ -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}}) diff --git a/src/main/haskell/Hydra/Encode/Coders.hs b/src/main/haskell/Hydra/Encode/Coders.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Coders.hs @@ -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}}) diff --git a/src/main/haskell/Hydra/Encode/Core.hs b/src/main/haskell/Hydra/Encode/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Core.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Error/Checking.hs b/src/main/haskell/Hydra/Encode/Error/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Error/Checking.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Error/Core.hs b/src/main/haskell/Hydra/Encode/Error/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Error/Core.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Errors.hs b/src/main/haskell/Hydra/Encode/Errors.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Errors.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Json/Model.hs b/src/main/haskell/Hydra/Encode/Json/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Json/Model.hs @@ -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))}}) diff --git a/src/main/haskell/Hydra/Encode/Packaging.hs b/src/main/haskell/Hydra/Encode/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Packaging.hs @@ -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}}) diff --git a/src/main/haskell/Hydra/Encode/Parsing.hs b/src/main/haskell/Hydra/Encode/Parsing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Parsing.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Paths.hs b/src/main/haskell/Hydra/Encode/Paths.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Paths.hs @@ -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}}) diff --git a/src/main/haskell/Hydra/Encode/Query.hs b/src/main/haskell/Hydra/Encode/Query.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Query.hs @@ -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))}) diff --git a/src/main/haskell/Hydra/Encode/Relational.hs b/src/main/haskell/Hydra/Encode/Relational.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Relational.hs @@ -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))}) diff --git a/src/main/haskell/Hydra/Encode/Tabular.hs b/src/main/haskell/Hydra/Encode/Tabular.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Tabular.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Testing.hs b/src/main/haskell/Hydra/Encode/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Testing.hs @@ -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))}) diff --git a/src/main/haskell/Hydra/Encode/Topology.hs b/src/main/haskell/Hydra/Encode/Topology.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Topology.hs @@ -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)) diff --git a/src/main/haskell/Hydra/Encode/Typed.hs b/src/main/haskell/Hydra/Encode/Typed.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Typed.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Typing.hs b/src/main/haskell/Hydra/Encode/Typing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Typing.hs @@ -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))}) diff --git a/src/main/haskell/Hydra/Encode/Util.hs b/src/main/haskell/Hydra/Encode/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Util.hs @@ -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))}]}) diff --git a/src/main/haskell/Hydra/Encode/Variants.hs b/src/main/haskell/Hydra/Encode/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encode/Variants.hs @@ -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}}) diff --git a/src/main/haskell/Hydra/Encoding.hs b/src/main/haskell/Hydra/Encoding.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Encoding.hs @@ -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 diff --git a/src/main/haskell/Hydra/Environment.hs b/src/main/haskell/Hydra/Environment.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Environment.hs @@ -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)) diff --git a/src/main/haskell/Hydra/Error/Checking.hs b/src/main/haskell/Hydra/Error/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Error/Checking.hs @@ -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" diff --git a/src/main/haskell/Hydra/Error/Core.hs b/src/main/haskell/Hydra/Error/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Error/Core.hs @@ -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" diff --git a/src/main/haskell/Hydra/Error/Packaging.hs b/src/main/haskell/Hydra/Error/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Error/Packaging.hs @@ -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" diff --git a/src/main/haskell/Hydra/Errors.hs b/src/main/haskell/Hydra/Errors.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Errors.hs @@ -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" diff --git a/src/main/haskell/Hydra/Extract/Core.hs b/src/main/haskell/Hydra/Extract/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Extract/Core.hs @@ -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)}))) diff --git a/src/main/haskell/Hydra/Extract/Json.hs b/src/main/haskell/Hydra/Extract/Json.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Extract/Json.hs @@ -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" diff --git a/src/main/haskell/Hydra/Extract/Util.hs b/src/main/haskell/Hydra/Extract/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Extract/Util.hs @@ -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)}))))))) diff --git a/src/main/haskell/Hydra/Formatting.hs b/src/main/haskell/Hydra/Formatting.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Formatting.hs @@ -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)))) diff --git a/src/main/haskell/Hydra/Graph.hs b/src/main/haskell/Hydra/Graph.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Graph.hs @@ -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" diff --git a/src/main/haskell/Hydra/Haskell/Lib/Chars.hs b/src/main/haskell/Hydra/Haskell/Lib/Chars.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Chars.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Eithers.hs b/src/main/haskell/Hydra/Haskell/Lib/Eithers.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Eithers.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Equality.hs b/src/main/haskell/Hydra/Haskell/Lib/Equality.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Equality.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Lists.hs b/src/main/haskell/Hydra/Haskell/Lib/Lists.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Lists.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Literals.hs b/src/main/haskell/Hydra/Haskell/Lib/Literals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Literals.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Logic.hs b/src/main/haskell/Hydra/Haskell/Lib/Logic.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Logic.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Maps.hs b/src/main/haskell/Hydra/Haskell/Lib/Maps.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Maps.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Math.hs b/src/main/haskell/Hydra/Haskell/Lib/Math.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Math.hs @@ -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) diff --git a/src/main/haskell/Hydra/Haskell/Lib/Optionals.hs b/src/main/haskell/Hydra/Haskell/Lib/Optionals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Optionals.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Pairs.hs b/src/main/haskell/Hydra/Haskell/Lib/Pairs.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Pairs.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Regex.hs b/src/main/haskell/Hydra/Haskell/Lib/Regex.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Regex.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Sets.hs b/src/main/haskell/Hydra/Haskell/Lib/Sets.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Sets.hs @@ -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 diff --git a/src/main/haskell/Hydra/Haskell/Lib/Strings.hs b/src/main/haskell/Hydra/Haskell/Lib/Strings.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Haskell/Lib/Strings.hs @@ -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 diff --git a/src/main/haskell/Hydra/Hoisting.hs b/src/main/haskell/Hydra/Hoisting.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Hoisting.hs @@ -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))) diff --git a/src/main/haskell/Hydra/Inference.hs b/src/main/haskell/Hydra/Inference.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Inference.hs @@ -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), + "."])) 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} diff --git a/src/main/haskell/Hydra/Json/Bootstrap.hs b/src/main/haskell/Hydra/Json/Bootstrap.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Bootstrap.hs @@ -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")))]))})))] diff --git a/src/main/haskell/Hydra/Json/Decode.hs b/src/main/haskell/Hydra/Json/Decode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Decode.hs @@ -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 diff --git a/src/main/haskell/Hydra/Json/Decoding.hs b/src/main/haskell/Hydra/Json/Decoding.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Decoding.hs @@ -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" diff --git a/src/main/haskell/Hydra/Json/Encode.hs b/src/main/haskell/Hydra/Json/Encode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Encode.hs @@ -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)]) diff --git a/src/main/haskell/Hydra/Json/Model.hs b/src/main/haskell/Hydra/Json/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Model.hs @@ -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" diff --git a/src/main/haskell/Hydra/Json/Parser.hs b/src/main/haskell/Hydra/Json/Parser.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Parser.hs @@ -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)]))) diff --git a/src/main/haskell/Hydra/Json/Writer.hs b/src/main/haskell/Hydra/Json/Writer.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Writer.hs @@ -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) diff --git a/src/main/haskell/Hydra/Json/Yaml/Decode.hs b/src/main/haskell/Hydra/Json/Yaml/Decode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Yaml/Decode.hs @@ -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) diff --git a/src/main/haskell/Hydra/Json/Yaml/Encode.hs b/src/main/haskell/Hydra/Json/Yaml/Encode.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Json/Yaml/Encode.hs @@ -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) diff --git a/src/main/haskell/Hydra/Kernel.hs b/src/main/haskell/Hydra/Kernel.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Kernel.hs @@ -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 diff --git a/src/main/haskell/Hydra/Languages.hs b/src/main/haskell/Hydra/Languages.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Languages.hs @@ -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 diff --git a/src/main/haskell/Hydra/Lexical.hs b/src/main/haskell/Hydra/Lexical.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lexical.hs @@ -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 diff --git a/src/main/haskell/Hydra/Lib/Chars.hs b/src/main/haskell/Hydra/Lib/Chars.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Chars.hs @@ -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} diff --git a/src/main/haskell/Hydra/Lib/Eithers.hs b/src/main/haskell/Hydra/Lib/Eithers.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Eithers.hs @@ -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.")))]))})))} diff --git a/src/main/haskell/Hydra/Lib/Equality.hs b/src/main/haskell/Hydra/Lib/Equality.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Equality.hs @@ -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.")))]))})))} diff --git a/src/main/haskell/Hydra/Lib/Lists.hs b/src/main/haskell/Hydra/Lib/Lists.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Lists.hs @@ -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} diff --git a/src/main/haskell/Hydra/Lib/Literals.hs b/src/main/haskell/Hydra/Lib/Literals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Literals.hs @@ -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} diff --git a/src/main/haskell/Hydra/Lib/Logic.hs b/src/main/haskell/Hydra/Lib/Logic.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Logic.hs @@ -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.")))]))})))} diff --git a/src/main/haskell/Hydra/Lib/Maps.hs b/src/main/haskell/Hydra/Lib/Maps.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Maps.hs @@ -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} diff --git a/src/main/haskell/Hydra/Lib/Math.hs b/src/main/haskell/Hydra/Lib/Math.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Math.hs @@ -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} diff --git a/src/main/haskell/Hydra/Lib/Optionals.hs b/src/main/haskell/Hydra/Lib/Optionals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Optionals.hs @@ -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.")))]))})))} diff --git a/src/main/haskell/Hydra/Lib/Pairs.hs b/src/main/haskell/Hydra/Lib/Pairs.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Pairs.hs @@ -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} diff --git a/src/main/haskell/Hydra/Lib/Regex.hs b/src/main/haskell/Hydra/Lib/Regex.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Regex.hs @@ -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} diff --git a/src/main/haskell/Hydra/Lib/Sets.hs b/src/main/haskell/Hydra/Lib/Sets.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Sets.hs @@ -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.")))]))})))} diff --git a/src/main/haskell/Hydra/Lib/Strings.hs b/src/main/haskell/Hydra/Lib/Strings.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Lib/Strings.hs @@ -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} diff --git a/src/main/haskell/Hydra/Literals.hs b/src/main/haskell/Hydra/Literals.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Literals.hs @@ -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 diff --git a/src/main/haskell/Hydra/Names.hs b/src/main/haskell/Hydra/Names.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Names.hs @@ -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))) diff --git a/src/main/haskell/Hydra/Packaging.hs b/src/main/haskell/Hydra/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Packaging.hs @@ -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" diff --git a/src/main/haskell/Hydra/Parsers.hs b/src/main/haskell/Hydra/Parsers.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Parsers.hs @@ -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})))) diff --git a/src/main/haskell/Hydra/Parsing.hs b/src/main/haskell/Hydra/Parsing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Parsing.hs @@ -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" diff --git a/src/main/haskell/Hydra/Paths.hs b/src/main/haskell/Hydra/Paths.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Paths.hs @@ -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" diff --git a/src/main/haskell/Hydra/Predicates.hs b/src/main/haskell/Hydra/Predicates.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Predicates.hs @@ -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) diff --git a/src/main/haskell/Hydra/Query.hs b/src/main/haskell/Hydra/Query.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Query.hs @@ -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" diff --git a/src/main/haskell/Hydra/Reduction.hs b/src/main/haskell/Hydra/Reduction.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Reduction.hs @@ -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 diff --git a/src/main/haskell/Hydra/Reflect.hs b/src/main/haskell/Hydra/Reflect.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Reflect.hs @@ -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] diff --git a/src/main/haskell/Hydra/Relational.hs b/src/main/haskell/Hydra/Relational.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Relational.hs @@ -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" diff --git a/src/main/haskell/Hydra/Resolution.hs b/src/main/haskell/Hydra/Resolution.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Resolution.hs @@ -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) diff --git a/src/main/haskell/Hydra/Rewriting.hs b/src/main/haskell/Hydra/Rewriting.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Rewriting.hs @@ -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] diff --git a/src/main/haskell/Hydra/Scoping.hs b/src/main/haskell/Hydra/Scoping.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Scoping.hs @@ -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} diff --git a/src/main/haskell/Hydra/Serialization.hs b/src/main/haskell/Hydra/Serialization.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Serialization.hs @@ -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 ";")] diff --git a/src/main/haskell/Hydra/Settings.hs b/src/main/haskell/Hydra/Settings.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Settings.hs @@ -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 diff --git a/src/main/haskell/Hydra/Show/Core.hs b/src/main/haskell/Hydra/Show/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Core.hs @@ -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), + ")"]) diff --git a/src/main/haskell/Hydra/Show/Error/Core.hs b/src/main/haskell/Hydra/Show/Error/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Error/Core.hs @@ -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" diff --git a/src/main/haskell/Hydra/Show/Error/Packaging.hs b/src/main/haskell/Hydra/Show/Error/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Error/Packaging.hs @@ -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"] diff --git a/src/main/haskell/Hydra/Show/Errors.hs b/src/main/haskell/Hydra/Show/Errors.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Errors.hs @@ -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)) diff --git a/src/main/haskell/Hydra/Show/Graph.hs b/src/main/haskell/Hydra/Show/Graph.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Graph.hs @@ -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), + "}"]) diff --git a/src/main/haskell/Hydra/Show/Paths.hs b/src/main/haskell/Hydra/Show/Paths.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Paths.hs @@ -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} diff --git a/src/main/haskell/Hydra/Show/Typing.hs b/src/main/haskell/Hydra/Show/Typing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Typing.hs @@ -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), + "}"]) diff --git a/src/main/haskell/Hydra/Show/Util.hs b/src/main/haskell/Hydra/Show/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Util.hs @@ -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" diff --git a/src/main/haskell/Hydra/Show/Variants.hs b/src/main/haskell/Hydra/Show/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Show/Variants.hs @@ -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" diff --git a/src/main/haskell/Hydra/Sorting.hs b/src/main/haskell/Hydra/Sorting.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sorting.hs @@ -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) diff --git a/src/main/haskell/Hydra/Sources/Decode/Ast.hs b/src/main/haskell/Hydra/Sources/Decode/Ast.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Ast.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Coders.hs b/src/main/haskell/Hydra/Sources/Decode/Coders.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Coders.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Core.hs b/src/main/haskell/Hydra/Sources/Decode/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Core.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs b/src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Error/Checking.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Error/Core.hs b/src/main/haskell/Hydra/Sources/Decode/Error/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Error/Core.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs b/src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Error/Packaging.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Errors.hs b/src/main/haskell/Hydra/Sources/Decode/Errors.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Errors.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Json/Model.hs b/src/main/haskell/Hydra/Sources/Decode/Json/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Json/Model.hs @@ -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")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Packaging.hs b/src/main/haskell/Hydra/Sources/Decode/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Packaging.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Parsing.hs b/src/main/haskell/Hydra/Sources/Decode/Parsing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Parsing.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Paths.hs b/src/main/haskell/Hydra/Sources/Decode/Paths.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Paths.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Query.hs b/src/main/haskell/Hydra/Sources/Decode/Query.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Query.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Relational.hs b/src/main/haskell/Hydra/Sources/Decode/Relational.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Relational.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Tabular.hs b/src/main/haskell/Hydra/Sources/Decode/Tabular.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Tabular.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Testing.hs b/src/main/haskell/Hydra/Sources/Decode/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Testing.hs @@ -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")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Topology.hs b/src/main/haskell/Hydra/Sources/Decode/Topology.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Topology.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Typed.hs b/src/main/haskell/Hydra/Sources/Decode/Typed.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Typed.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Typing.hs b/src/main/haskell/Hydra/Sources/Decode/Typing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Typing.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Util.hs b/src/main/haskell/Hydra/Sources/Decode/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Util.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Validation.hs b/src/main/haskell/Hydra/Sources/Decode/Validation.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Validation.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Decode/Variants.hs b/src/main/haskell/Hydra/Sources/Decode/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Decode/Variants.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Ast.hs b/src/main/haskell/Hydra/Sources/Encode/Ast.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Ast.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Coders.hs b/src/main/haskell/Hydra/Sources/Encode/Coders.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Coders.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Core.hs b/src/main/haskell/Hydra/Sources/Encode/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Core.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs b/src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Error/Checking.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Error/Core.hs b/src/main/haskell/Hydra/Sources/Encode/Error/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Error/Core.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs b/src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Error/Packaging.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Errors.hs b/src/main/haskell/Hydra/Sources/Encode/Errors.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Errors.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Json/Model.hs b/src/main/haskell/Hydra/Sources/Encode/Json/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Json/Model.hs @@ -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")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Packaging.hs b/src/main/haskell/Hydra/Sources/Encode/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Packaging.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Parsing.hs b/src/main/haskell/Hydra/Sources/Encode/Parsing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Parsing.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Paths.hs b/src/main/haskell/Hydra/Sources/Encode/Paths.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Paths.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Query.hs b/src/main/haskell/Hydra/Sources/Encode/Query.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Query.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Relational.hs b/src/main/haskell/Hydra/Sources/Encode/Relational.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Relational.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Tabular.hs b/src/main/haskell/Hydra/Sources/Encode/Tabular.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Tabular.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Testing.hs b/src/main/haskell/Hydra/Sources/Encode/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Testing.hs @@ -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")))]))}))})]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Topology.hs b/src/main/haskell/Hydra/Sources/Encode/Topology.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Topology.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Typed.hs b/src/main/haskell/Hydra/Sources/Encode/Typed.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Typed.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Typing.hs b/src/main/haskell/Hydra/Sources/Encode/Typing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Typing.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Util.hs b/src/main/haskell/Hydra/Sources/Encode/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Util.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Validation.hs b/src/main/haskell/Hydra/Sources/Encode/Validation.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Validation.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Sources/Encode/Variants.hs b/src/main/haskell/Hydra/Sources/Encode/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Sources/Encode/Variants.hs @@ -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")))]))}))}))]} diff --git a/src/main/haskell/Hydra/Strip.hs b/src/main/haskell/Hydra/Strip.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Strip.hs @@ -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 diff --git a/src/main/haskell/Hydra/Substitution.hs b/src/main/haskell/Hydra/Substitution.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Substitution.hs @@ -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) diff --git a/src/main/haskell/Hydra/Tabular.hs b/src/main/haskell/Hydra/Tabular.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Tabular.hs @@ -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" diff --git a/src/main/haskell/Hydra/Templates.hs b/src/main/haskell/Hydra/Templates.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Templates.hs @@ -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}))) diff --git a/src/main/haskell/Hydra/Test/Transform.hs b/src/main/haskell/Hydra/Test/Transform.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Test/Transform.hs @@ -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}))) diff --git a/src/main/haskell/Hydra/Test/Utils.hs b/src/main/haskell/Hydra/Test/Utils.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Test/Utils.hs @@ -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_))) diff --git a/src/main/haskell/Hydra/Testing.hs b/src/main/haskell/Hydra/Testing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Testing.hs @@ -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" diff --git a/src/main/haskell/Hydra/Topology.hs b/src/main/haskell/Hydra/Topology.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Topology.hs @@ -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" diff --git a/src/main/haskell/Hydra/Typed.hs b/src/main/haskell/Hydra/Typed.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Typed.hs @@ -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" diff --git a/src/main/haskell/Hydra/Typing.hs b/src/main/haskell/Hydra/Typing.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Typing.hs @@ -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" diff --git a/src/main/haskell/Hydra/Unification.hs b/src/main/haskell/Hydra/Unification.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Unification.hs @@ -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) diff --git a/src/main/haskell/Hydra/Util.hs b/src/main/haskell/Hydra/Util.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Util.hs @@ -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" diff --git a/src/main/haskell/Hydra/Validate/Core.hs b/src/main/haskell/Hydra/Validate/Core.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Validate/Core.hs @@ -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 diff --git a/src/main/haskell/Hydra/Validate/Packaging.hs b/src/main/haskell/Hydra/Validate/Packaging.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Validate/Packaging.hs @@ -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)) diff --git a/src/main/haskell/Hydra/Validation.hs b/src/main/haskell/Hydra/Validation.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Validation.hs @@ -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...', 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" diff --git a/src/main/haskell/Hydra/Variables.hs b/src/main/haskell/Hydra/Variables.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Variables.hs @@ -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) diff --git a/src/main/haskell/Hydra/Variants.hs b/src/main/haskell/Hydra/Variants.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Variants.hs @@ -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" diff --git a/src/main/haskell/Hydra/Yaml/Model.hs b/src/main/haskell/Hydra/Yaml/Model.hs new file mode 100644 --- /dev/null +++ b/src/main/haskell/Hydra/Yaml/Model.hs @@ -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"